From ec1f98abd3752459e372f0228041e233f0fd6c7e Mon Sep 17 00:00:00 2001 From: Max Sagebaum Date: Fri, 31 Jan 2025 02:47:02 +0100 Subject: [PATCH] Updates for missing features in regular expressions. (#1337) * Added handling of \G. * Added find_all method to regular expressions. * Implementation of reverse token generation. * Implementation of lookbehind parsing. * Hack for reverse matching. * Removed Iter from wrapper and added it to the generated functions. * Removed `wrap` helper. * Implementation of advanced regexes. * Added implementation for nested lookaround. * Update for regex status. * Added atomic grouping token. * Code cleanup. * Update of Regression tests. * Header update for new version. * Updates for clang. * Update for tests. --- docs/notes/regex_status.md | 20 +- include/cpp2regex.h | 725 +- include/cpp2regex.h2 | 223 +- regression-tests/pure2-regex-general.cpp2 | 32 + .../pure2-regex_01_char_matcher.cpp2 | 1 + regression-tests/pure2-regex_02_ranges.cpp2 | 1 + regression-tests/pure2-regex_03_wildcard.cpp2 | 1 + .../pure2-regex_04_start_end.cpp2 | 3 + regression-tests/pure2-regex_05_classes.cpp2 | 1 + .../pure2-regex_06_boundaries.cpp2 | 1 + .../pure2-regex_07_short_classes.cpp2 | 1 + .../pure2-regex_08_alternatives.cpp2 | 1 + regression-tests/pure2-regex_09_groups.cpp2 | 1 + regression-tests/pure2-regex_10_escapes.cpp2 | 1 + .../pure2-regex_11_group_references.cpp2 | 1 + .../pure2-regex_12_case_insensitive.cpp2 | 1 + .../pure2-regex_13_possessive_modifier.cpp2 | 1 + .../pure2-regex_14_multiline_modifier.cpp2 | 1 + .../pure2-regex_15_group_modifiers.cpp2 | 1 + .../pure2-regex_16_perl_syntax_modifier.cpp2 | 1 + regression-tests/pure2-regex_17_comments.cpp2 | 1 + .../pure2-regex_18_branch_reset.cpp2 | 1 + .../pure2-regex_19_lookahead.cpp2 | 21 + .../pure2-regex_20_lookbehind.cpp | 8989 +++++++++++++++++ .../pure2-regex_21_atomic_patterns.cpp2 | 186 + .../pure2-regex-general.cpp.execution | 11 + .../pure2-regex_04_start_end.cpp.execution | 1 + .../pure2-regex_19_lookahead.cpp.execution | 10 + ...re2-regex_21_atomic_patterns.cpp.execution | 8 + .../pure2-regex-general.cpp.execution | 11 + .../pure2-regex_04_start_end.cpp.execution | 1 + .../pure2-regex_19_lookahead.cpp.execution | 10 + ...re2-regex_21_atomic_patterns.cpp.execution | 8 + .../pure2-regex-general.cpp.execution | 11 + .../pure2-regex_04_start_end.cpp.execution | 1 + .../pure2-regex_19_lookahead.cpp.execution | 10 + ...re2-regex_21_atomic_patterns.cpp.execution | 8 + .../pure2-regex-general.cpp.execution | 11 + .../pure2-regex_04_start_end.cpp.execution | 1 + .../pure2-regex_19_lookahead.cpp.execution | 10 + ...re2-regex_21_atomic_patterns.cpp.execution | 8 + .../pure2-regex-general.cpp.output | 78 + .../pure2-regex_04_start_end.cpp.execution | 1 + .../pure2-regex_19_lookahead.cpp.execution | 10 + ...re2-regex_21_atomic_patterns.cpp.execution | 8 + .../pure2-regex-general.cpp.execution | 11 + .../pure2-regex_04_start_end.cpp.execution | 1 + .../pure2-regex_19_lookahead.cpp.execution | 10 + ...re2-regex_21_atomic_patterns.cpp.execution | 8 + .../pure2-regex-general.cpp.execution | 11 + .../pure2-regex_04_start_end.cpp.execution | 1 + .../pure2-regex_19_lookahead.cpp.execution | 10 + ...re2-regex_21_atomic_patterns.cpp.execution | 8 + .../pure2-regex-general.cpp.execution | 11 + .../pure2-regex_04_start_end.cpp.execution | 1 + .../pure2-regex_19_lookahead.cpp.execution | 10 + ...re2-regex_21_atomic_patterns.cpp.execution | 8 + .../pure2-regex-general.cpp.execution | 11 + .../pure2-regex-general.cpp.output | 1 + .../pure2-regex_04_start_end.cpp.execution | 1 + .../pure2-regex_19_lookahead.cpp.execution | 10 + ...re2-regex_21_atomic_patterns.cpp.execution | 8 + .../pure2-regex_21_atomic_patterns.cpp.output | 1 + .../pure2-regex-general.cpp.execution | 11 + .../pure2-regex-general.cpp.output | 1 + .../pure2-regex_04_start_end.cpp.execution | 1 + .../pure2-regex_19_lookahead.cpp.execution | 10 + ...re2-regex_21_atomic_patterns.cpp.execution | 8 + .../pure2-regex_21_atomic_patterns.cpp.output | 1 + .../test-results/pure2-regex-general.cpp | 236 + .../pure2-regex-general.cpp2.output | 2 + .../pure2-regex_01_char_matcher.cpp | 371 +- .../test-results/pure2-regex_02_ranges.cpp | 1583 ++- .../test-results/pure2-regex_03_wildcard.cpp | 773 +- .../test-results/pure2-regex_04_start_end.cpp | 420 +- .../test-results/pure2-regex_05_classes.cpp | 574 +- .../pure2-regex_06_boundaries.cpp | 516 +- .../pure2-regex_07_short_classes.cpp | 719 +- .../pure2-regex_08_alternatives.cpp | 111 +- .../test-results/pure2-regex_09_groups.cpp | 342 +- .../test-results/pure2-regex_10_escapes.cpp | 683 +- .../pure2-regex_11_group_references.cpp | 895 +- .../pure2-regex_12_case_insensitive.cpp | 4880 +++++---- .../pure2-regex_13_possessive_modifier.cpp | 2319 +++-- .../pure2-regex_14_multiline_modifier.cpp | 5796 +++++------ .../pure2-regex_15_group_modifiers.cpp | 1590 ++- .../pure2-regex_16_perl_syntax_modifier.cpp | 1140 +-- .../test-results/pure2-regex_17_comments.cpp | 130 +- .../pure2-regex_18_branch_reset.cpp | 859 +- .../test-results/pure2-regex_19_lookahead.cpp | 3722 ++++--- .../pure2-regex_20_lookbehind.cpp.output | 3 + .../pure2-regex_21_atomic_patterns.cpp | 1616 +++ ...pure2-regex_21_atomic_patterns.cpp2.output | 2 + source/reflect.h | 1010 +- source/reflect.h2 | 253 +- 95 files changed, 26156 insertions(+), 14976 deletions(-) create mode 100644 regression-tests/pure2-regex-general.cpp2 create mode 100644 regression-tests/pure2-regex_20_lookbehind.cpp create mode 100644 regression-tests/pure2-regex_21_atomic_patterns.cpp2 create mode 100644 regression-tests/test-results/apple-clang-14-c++2b/pure2-regex-general.cpp.execution create mode 100644 regression-tests/test-results/apple-clang-14-c++2b/pure2-regex_21_atomic_patterns.cpp.execution create mode 100644 regression-tests/test-results/clang-12-c++20/pure2-regex-general.cpp.execution create mode 100644 regression-tests/test-results/clang-12-c++20/pure2-regex_21_atomic_patterns.cpp.execution create mode 100644 regression-tests/test-results/clang-15-c++20-libcpp/pure2-regex-general.cpp.execution create mode 100644 regression-tests/test-results/clang-15-c++20-libcpp/pure2-regex_21_atomic_patterns.cpp.execution create mode 100644 regression-tests/test-results/clang-15-c++20/pure2-regex-general.cpp.execution create mode 100644 regression-tests/test-results/clang-15-c++20/pure2-regex_21_atomic_patterns.cpp.execution create mode 100644 regression-tests/test-results/clang-18-c++20/pure2-regex-general.cpp.output create mode 100644 regression-tests/test-results/clang-18-c++20/pure2-regex_21_atomic_patterns.cpp.execution create mode 100644 regression-tests/test-results/gcc-10-c++20/pure2-regex-general.cpp.execution create mode 100644 regression-tests/test-results/gcc-10-c++20/pure2-regex_21_atomic_patterns.cpp.execution create mode 100644 regression-tests/test-results/gcc-13-c++2b/pure2-regex-general.cpp.execution create mode 100644 regression-tests/test-results/gcc-13-c++2b/pure2-regex_21_atomic_patterns.cpp.execution create mode 100644 regression-tests/test-results/gcc-14-c++2b/pure2-regex-general.cpp.execution create mode 100644 regression-tests/test-results/gcc-14-c++2b/pure2-regex_21_atomic_patterns.cpp.execution create mode 100644 regression-tests/test-results/msvc-2022-c++20/pure2-regex-general.cpp.execution create mode 100644 regression-tests/test-results/msvc-2022-c++20/pure2-regex-general.cpp.output create mode 100644 regression-tests/test-results/msvc-2022-c++20/pure2-regex_21_atomic_patterns.cpp.execution create mode 100644 regression-tests/test-results/msvc-2022-c++20/pure2-regex_21_atomic_patterns.cpp.output create mode 100644 regression-tests/test-results/msvc-2022-c++latest/pure2-regex-general.cpp.execution create mode 100644 regression-tests/test-results/msvc-2022-c++latest/pure2-regex-general.cpp.output create mode 100644 regression-tests/test-results/msvc-2022-c++latest/pure2-regex_21_atomic_patterns.cpp.execution create mode 100644 regression-tests/test-results/msvc-2022-c++latest/pure2-regex_21_atomic_patterns.cpp.output create mode 100644 regression-tests/test-results/pure2-regex-general.cpp create mode 100644 regression-tests/test-results/pure2-regex-general.cpp2.output create mode 100644 regression-tests/test-results/pure2-regex_20_lookbehind.cpp.output create mode 100644 regression-tests/test-results/pure2-regex_21_atomic_patterns.cpp create mode 100644 regression-tests/test-results/pure2-regex_21_atomic_patterns.cpp2.output diff --git a/docs/notes/regex_status.md b/docs/notes/regex_status.md index fa43c928a7..0ef8ef7f8e 100644 --- a/docs/notes/regex_status.md +++ b/docs/notes/regex_status.md @@ -15,7 +15,7 @@ The listings are taken from the [Perl regex docs](https://perldoc.perl.org/perlr | **`s`** | Treat the string as single line. That is, change `.` to match any character whatsoever, even a newline, which normally it would not match. | Supported | | ***`x` and `xx`** | Extend your pattern's legibility by permitting whitespace and comments. For details see: [Perl regex docs: `/x` and `/xx`](https://perldoc.perl.org/perlre#/x-and-/xx). | Supported | | **`n`** | Prevent the grouping metacharacters `(` and `)` from capturing. This modifier will stop `$1`, `$2`, etc. from being filled in. | Supported | -| **`c`** | Keep the current position during repeated matching. | Planned | +| **`c`** | Keep the current position during repeated matching. | Supported | ### Escape sequences __(Complete)__ @@ -96,7 +96,7 @@ The listings are taken from the [Perl regex docs](https://perldoc.perl.org/perlr | **`\A`** | Match only at beginning of string | Supported | | **`\Z`** | Match only at end of string, or before newline at the end | Supported | | **`\z`** | Match only at end of string | Supported | -| **`\G`** | Match only at pos() (e.g. at the end-of-match position of prior m//g) | Planned | +| **`\G`** | Match only at pos() (e.g. at the end-of-match position of prior m//g) | Supported | ### Capture groups __(Complete)__ @@ -128,8 +128,8 @@ The listings are taken from the [Perl regex docs](https://perldoc.perl.org/perlr | **`(?'NAME'pattern)`** | Named capture group | Supported | | **`(?(condition)yes-pattern`|`no-pattern)`** | Conditional patterns. | Planned | | **`(?(condition)yes-pattern)`** | Conditional patterns. | Planned | -| **`(?>pattern)`** | Atomic patterns. (Disable backtrack.) | Planned | -| **`(*atomic:pattern)`** | Atomic patterns. (Disable backtrack.) | Planned | +| **`(?>pattern)`** | Atomic patterns. (Disable backtrack.) | Supported | +| **`(*atomic:pattern)`** | Atomic patterns. (Disable backtrack.) | Supported | ### Lookaround Assertions @@ -142,12 +142,12 @@ The listings are taken from the [Perl regex docs](https://perldoc.perl.org/perlr | **`(?!pattern)`** | Negative look ahead. | Supported | | **`(*nla:pattern)`** | Negative look ahead. | Supported | | **`(*negative_lookahead:pattern)`** | Negative look ahead. | Supported | -| **`(?<=pattern)`** | Positive look behind. | Planned | -| **`(*plb:pattern)`** | Positive look behind. | Planned | -| **`(*positive_lookbehind:pattern)`** | Positive look behind. | Planned | -| **`(?Planned | -| **`(*nlb:pattern)`** | Negative look behind. | Planned | -| **`(*negative_lookbehind:pattern)`** | Negative look behind. | Planned | +| **`(?<=pattern)`** | Positive look behind. | Supported | +| **`(*plb:pattern)`** | Positive look behind. | Supported | +| **`(*positive_lookbehind:pattern)`** | Positive look behind. | Supported | +| **`(?Supported | +| **`(*nlb:pattern)`** | Negative look behind. | Supported | +| **`(*negative_lookbehind:pattern)`** | Negative look behind. | Supported | ### Special Backtracking Control Verbs diff --git a/include/cpp2regex.h b/include/cpp2regex.h index 27b4f2b9b3..abf28a1cba 100644 --- a/include/cpp2regex.h +++ b/include/cpp2regex.h @@ -10,67 +10,70 @@ #line 1 "cpp2regex.h2" -#line 22 "cpp2regex.h2" +#line 20 "cpp2regex.h2" namespace cpp2 { namespace regex { -#line 38 "cpp2regex.h2" +#line 36 "cpp2regex.h2" template class match_group; -#line 48 "cpp2regex.h2" +#line 46 "cpp2regex.h2" template class match_return; -#line 56 "cpp2regex.h2" +#line 54 "cpp2regex.h2" template class match_context; -#line 117 "cpp2regex.h2" +#line 125 "cpp2regex.h2" +template class reverse_match_context; + +#line 194 "cpp2regex.h2" class true_end_func; -#line 125 "cpp2regex.h2" +#line 202 "cpp2regex.h2" class no_reset; -#line 132 "cpp2regex.h2" +#line 209 "cpp2regex.h2" template class on_return; -#line 159 "cpp2regex.h2" +#line 236 "cpp2regex.h2" template class single_class_entry; -#line 168 "cpp2regex.h2" +#line 245 "cpp2regex.h2" template class range_class_entry; -#line 177 "cpp2regex.h2" +#line 254 "cpp2regex.h2" template class combined_class_entry; -#line 186 "cpp2regex.h2" +#line 263 "cpp2regex.h2" template class list_class_entry; -#line 195 "cpp2regex.h2" +#line 272 "cpp2regex.h2" template class named_class_entry; -#line 202 "cpp2regex.h2" +#line 279 "cpp2regex.h2" template class negated_class_entry; -#line 211 "cpp2regex.h2" +#line 288 "cpp2regex.h2" template class shorthand_class_entry; -#line 259 "cpp2regex.h2" +#line 336 "cpp2regex.h2" template class alternative_token_matcher; -#line 337 "cpp2regex.h2" +#line 427 "cpp2regex.h2" template class class_token_matcher; -#line 492 "cpp2regex.h2" +#line 604 "cpp2regex.h2" class range_flags; -#line 501 "cpp2regex.h2" +#line 613 "cpp2regex.h2" template class range_token_matcher; -#line 673 "cpp2regex.h2" -template class regular_expression; +#line 785 "cpp2regex.h2" +template class regular_expression; -#line 756 "cpp2regex.h2" +#line 921 "cpp2regex.h2" } } @@ -93,13 +96,11 @@ template class regular_expression; #ifndef CPP2_CPP2REGEX_H #define CPP2_CPP2REGEX_H -template -using matcher_wrapper_type = typename matcher_wrapper::template wrap; -template -using matcher_context_type = typename matcher::context; +template +using matcher_context_type = typename matcher::template context; -#line 22 "cpp2regex.h2" +#line 20 "cpp2regex.h2" namespace cpp2 { namespace regex { @@ -125,7 +126,7 @@ template class match_group public: match_group(auto const& start_, auto const& end_, auto const& matched_); public: match_group(); -#line 44 "cpp2regex.h2" +#line 42 "cpp2regex.h2" }; // Return value for every matcher. @@ -137,7 +138,7 @@ template class match_return public: match_return(auto const& matched_, auto const& pos_); public: match_return(); -#line 52 "cpp2regex.h2" +#line 50 "cpp2regex.h2" }; // Modifiable state during matching. @@ -151,46 +152,121 @@ template class match_context public: match_context(Iter const& begin_, Iter const& end_); -#line 68 "cpp2regex.h2" +#line 66 "cpp2regex.h2" public: match_context(match_context const& that); -#line 68 "cpp2regex.h2" +#line 66 "cpp2regex.h2" public: auto operator=(match_context const& that) -> match_context& ; -#line 68 "cpp2regex.h2" +#line 66 "cpp2regex.h2" public: match_context(match_context&& that) noexcept; -#line 68 "cpp2regex.h2" +#line 66 "cpp2regex.h2" public: auto operator=(match_context&& that) noexcept -> match_context& ; + // String end and start positions + // + public: [[nodiscard]] auto get_string_start() const& -> decltype(auto); + public: [[nodiscard]] auto get_string_end() const& -> decltype(auto); + // Getter and setter for groups // public: [[nodiscard]] auto get_group(auto const& group) const& -> decltype(auto); public: [[nodiscard]] auto get_group_end(auto const& group) const& -> int; -#line 80 "cpp2regex.h2" +#line 83 "cpp2regex.h2" public: [[nodiscard]] auto get_group_start(auto const& group) const& -> int; -#line 86 "cpp2regex.h2" +#line 89 "cpp2regex.h2" public: [[nodiscard]] auto get_group_string(auto const& group) const& -> std::string; -#line 93 "cpp2regex.h2" +#line 96 "cpp2regex.h2" public: auto set_group_end(auto const& group, auto const& pos) & -> void; -#line 98 "cpp2regex.h2" +#line 101 "cpp2regex.h2" public: auto set_group_invalid(auto const& group) & -> void; -#line 102 "cpp2regex.h2" +#line 105 "cpp2regex.h2" public: auto set_group_start(auto const& group, auto const& pos) & -> void; -#line 106 "cpp2regex.h2" +#line 109 "cpp2regex.h2" public: [[nodiscard]] auto size() const& -> decltype(auto); // Misc functions // public: [[nodiscard]] auto fail() const& -> decltype(auto); public: [[nodiscard]] auto pass(cpp2::impl::in cur) const& -> decltype(auto); + + public: auto reset() & -> void; + +#line 121 "cpp2regex.h2" }; -#line 115 "cpp2regex.h2" +// Wrapper of context for reverse matches. Implements only the minimal interface for matching. +// +template class reverse_match_context + { + public: using ReverseIter = std::reverse_iterator; + public: match_context* forward_context; + + public: ReverseIter begin; + public: ReverseIter end; + + public: reverse_match_context(auto const& forward_context_); +#line 133 "cpp2regex.h2" + public: auto operator=(auto const& forward_context_) -> reverse_match_context& ; + +#line 139 "cpp2regex.h2" + public: reverse_match_context(reverse_match_context const& that); +#line 139 "cpp2regex.h2" + public: auto operator=(reverse_match_context const& that) -> reverse_match_context& ; +#line 139 "cpp2regex.h2" + public: reverse_match_context(reverse_match_context&& that) noexcept; +#line 139 "cpp2regex.h2" + public: auto operator=(reverse_match_context&& that) noexcept -> reverse_match_context& ; + + // String end and start positions + // + public: [[nodiscard]] auto get_string_start() const& -> decltype(auto); + public: [[nodiscard]] auto get_string_end() const& -> decltype(auto); + + // Getter and setter for groups + // + public: auto set_group_end(auto const& group, auto const& pos) & -> void; + +#line 152 "cpp2regex.h2" + public: auto set_group_invalid(auto const& group) & -> void; + +#line 156 "cpp2regex.h2" + public: auto set_group_start(auto const& group, auto const& pos) & -> void; + +#line 160 "cpp2regex.h2" + // Misc functions + // + public: [[nodiscard]] auto fail() const& -> decltype(auto); + public: [[nodiscard]] auto pass(cpp2::impl::in cur) const& -> decltype(auto); +}; + +// Helpers for creating wrappers of the match context. +// +template [[nodiscard]] auto make_forward_match_context(match_context& ctx) -> decltype(auto); + +#line 172 "cpp2regex.h2" +template [[nodiscard]] auto make_forward_match_context(reverse_match_context& ctx) -> decltype(auto); + +#line 176 "cpp2regex.h2" +template [[nodiscard]] auto make_reverse_match_context(match_context& ctx) -> auto; + +#line 180 "cpp2regex.h2" +template [[nodiscard]] auto make_reverse_match_context(reverse_match_context& ctx) -> decltype(auto); + +#line 184 "cpp2regex.h2" +// Helpers for creating wrappers of the iterators. +// +template [[nodiscard]] auto make_forward_iterator(Iter const& pos) -> auto; +template [[nodiscard]] auto make_forward_iterator(std::reverse_iterator const& pos) -> auto; +template [[nodiscard]] auto make_reverse_iterator(Iter const& pos) -> auto; +template [[nodiscard]] auto make_reverse_iterator(std::reverse_iterator const& pos) -> auto; + +#line 192 "cpp2regex.h2" // End function that returns a valid match. // class true_end_func @@ -198,7 +274,7 @@ class true_end_func public: [[nodiscard]] auto operator()(auto const& cur, auto& ctx) const& -> decltype(auto); }; -#line 123 "cpp2regex.h2" +#line 200 "cpp2regex.h2" // Empty group reset function. // class no_reset @@ -206,30 +282,30 @@ class no_reset public: auto operator()([[maybe_unused]] auto& unnamed_param_2) const& -> void; }; -#line 131 "cpp2regex.h2" +#line 208 "cpp2regex.h2" // Evaluate func on destruction of the handle. template class on_return { private: Func func; public: on_return(Func const& f); -#line 136 "cpp2regex.h2" +#line 213 "cpp2regex.h2" public: auto operator=(Func const& f) -> on_return& ; -#line 140 "cpp2regex.h2" +#line 217 "cpp2regex.h2" public: ~on_return() noexcept; public: on_return(on_return const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(on_return const&) -> void = delete; -#line 143 "cpp2regex.h2" +#line 220 "cpp2regex.h2" }; -#line 146 "cpp2regex.h2" +#line 223 "cpp2regex.h2" // Helper for auto deduction of the Func type. template [[nodiscard]] auto make_on_return(Func const& func) -> decltype(auto); -#line 150 "cpp2regex.h2" +#line 227 "cpp2regex.h2" //----------------------------------------------------------------------- // // Character classes for regular expressions. @@ -247,10 +323,10 @@ template class single_class_entry public: single_class_entry(single_class_entry const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(single_class_entry const&) -> void = delete; -#line 163 "cpp2regex.h2" +#line 240 "cpp2regex.h2" }; -#line 166 "cpp2regex.h2" +#line 243 "cpp2regex.h2" // Class syntax: - Example: a-c // template class range_class_entry @@ -261,10 +337,10 @@ template class range_class_entry public: range_class_entry(range_class_entry const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(range_class_entry const&) -> void = delete; -#line 172 "cpp2regex.h2" +#line 249 "cpp2regex.h2" }; -#line 175 "cpp2regex.h2" +#line 252 "cpp2regex.h2" // Helper for combining two character classes // template class combined_class_entry @@ -275,10 +351,10 @@ template class combined_class_entry public: combined_class_entry(combined_class_entry const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(combined_class_entry const&) -> void = delete; -#line 181 "cpp2regex.h2" +#line 258 "cpp2regex.h2" }; -#line 184 "cpp2regex.h2" +#line 261 "cpp2regex.h2" // Class syntax: Example: abcd // template class list_class_entry @@ -289,10 +365,10 @@ template class list_class_entry public: list_class_entry(list_class_entry const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(list_class_entry const&) -> void = delete; -#line 190 "cpp2regex.h2" +#line 267 "cpp2regex.h2" }; -#line 193 "cpp2regex.h2" +#line 270 "cpp2regex.h2" // Class syntax: [: class named_class_entry @@ -303,10 +379,10 @@ template class n public: named_class_entry(named_class_entry const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(named_class_entry const&) -> void = delete; -#line 199 "cpp2regex.h2" +#line 276 "cpp2regex.h2" }; -#line 202 "cpp2regex.h2" +#line 279 "cpp2regex.h2" template class negated_class_entry : public Inner { @@ -315,10 +391,10 @@ template class negated_class_entry public: negated_class_entry(negated_class_entry const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(negated_class_entry const&) -> void = delete; -#line 206 "cpp2regex.h2" +#line 283 "cpp2regex.h2" }; -#line 209 "cpp2regex.h2" +#line 286 "cpp2regex.h2" // Short class syntax: \ Example: \w // template class shorthand_class_entry @@ -329,10 +405,10 @@ template class s public: shorthand_class_entry(shorthand_class_entry const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(shorthand_class_entry const&) -> void = delete; -#line 215 "cpp2regex.h2" +#line 292 "cpp2regex.h2" }; -#line 218 "cpp2regex.h2" +#line 295 "cpp2regex.h2" // Named basic character classes // template using digits_class = named_class_entry>; @@ -369,7 +445,7 @@ template using short_not_space_class = nega template using short_not_vert_space_class = negated_class_entry>>; template using short_not_word_class = negated_class_entry>>; -#line 255 "cpp2regex.h2" +#line 332 "cpp2regex.h2" // Regex syntax: | Example: ab|ba // // Non greedy implementation. First alternative that matches is chosen. @@ -378,22 +454,27 @@ template class alternative_token_matcher { public: [[nodiscard]] static auto match(auto const& cur, auto& ctx, auto const& end_func, auto const& tail, auto const& ...functions) -> auto; -#line 265 "cpp2regex.h2" +#line 342 "cpp2regex.h2" private: template [[nodiscard]] static auto match_first(auto const& cur, auto& ctx, auto const& end_func, auto const& tail, auto const& cur_func, auto const& cur_reset, Other const& ...other) -> auto; public: alternative_token_matcher() = default; public: alternative_token_matcher(alternative_token_matcher const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(alternative_token_matcher const&) -> void = delete; -#line 283 "cpp2regex.h2" +#line 360 "cpp2regex.h2" }; -#line 286 "cpp2regex.h2" +#line 363 "cpp2regex.h2" // Regex syntax: . // template [[nodiscard]] auto any_token_matcher(auto& cur, auto& ctx) -> bool; -#line 301 "cpp2regex.h2" +#line 377 "cpp2regex.h2" +// Regex syntax: (?>) Example: a(?>bc|c)c +// +template [[nodiscard]] auto atomic_group_matcher(Iter const& cur, auto& ctx, auto const& inner, auto const& end_func, auto const& other) -> auto; + +#line 391 "cpp2regex.h2" // TODO: Check if vectorization works at some point with this implementation. // char_token_matcher: (inout cur, inout ctx) -> bool = { // if !(std::distance(cur, ctx.end) < tokens..size()) { @@ -427,21 +508,21 @@ template [[nodiscard]] auto any_token_matcher( // return matched; // } -#line 335 "cpp2regex.h2" +#line 425 "cpp2regex.h2" // Regex syntax: [] Example: [abcx-y[:digits:]] // template class class_token_matcher { public: [[nodiscard]] static auto match(auto& cur, auto& ctx) -> bool; -#line 368 "cpp2regex.h2" +#line 458 "cpp2regex.h2" private: template [[nodiscard]] static auto match_any(cpp2::impl::in c) -> bool; public: class_token_matcher() = default; public: class_token_matcher(class_token_matcher const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(class_token_matcher const&) -> void = delete; -#line 381 "cpp2regex.h2" +#line 471 "cpp2regex.h2" // TODO: Implement proper to string // to_string: () -> bstring = { // r: bstring = "["; @@ -453,10 +534,10 @@ template c // return r; // } -#line 392 "cpp2regex.h2" +#line 482 "cpp2regex.h2" }; -#line 395 "cpp2regex.h2" +#line 485 "cpp2regex.h2" // Named short classes // template using named_class_no_new_line = class_token_matcher>; @@ -472,36 +553,43 @@ template usi template using named_class_not_ver_space = class_token_matcher>; template using named_class_not_word = class_token_matcher>; -#line 411 "cpp2regex.h2" +#line 501 "cpp2regex.h2" // Regex syntax: \ Example: \1 // \g{name_or_number} // \k{name_or_number} // \k // \k'name_or_number' // -template [[nodiscard]] auto group_ref_token_matcher(auto& cur, auto& ctx) -> bool; +template [[nodiscard]] auto group_ref_token_matcher(auto& cur, auto& ctx) -> bool; -#line 448 "cpp2regex.h2" +#line 546 "cpp2regex.h2" // Regex syntax: $ Example: aa$ // template [[nodiscard]] auto line_end_token_matcher(auto const& cur, auto& ctx) -> bool; -#line 464 "cpp2regex.h2" +#line 562 "cpp2regex.h2" // Regex syntax: ^ Example: ^aa // template [[nodiscard]] auto line_start_token_matcher(auto const& cur, auto& ctx) -> bool; -#line 473 "cpp2regex.h2" +#line 571 "cpp2regex.h2" // Regex syntax: (?=) or (?!) or (*pla), etc. Example: (?=AA) // // Parsed in group_token. // template [[nodiscard]] auto lookahead_token_matcher(auto const& cur, auto& ctx, auto const& func) -> bool; -#line 488 "cpp2regex.h2" +#line 585 "cpp2regex.h2" +// Regex syntax: (?<=) or (? [[nodiscard]] auto lookbehind_token_matcher(auto const& cur, auto& ctx, auto const& func) -> bool; + +#line 600 "cpp2regex.h2" // TODO: @enum as template parameter currently not working. See issue https://github.com/hsutter/cppfront/issues/1147 -#line 491 "cpp2regex.h2" +#line 603 "cpp2regex.h2" // Options for range matching. class range_flags { public: static const int not_greedy;// Try to take as few as possible. @@ -512,9 +600,9 @@ class range_flags { public: range_flags(range_flags const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(range_flags const&) -> void = delete; }; -#line 497 "cpp2regex.h2" +#line 609 "cpp2regex.h2" -#line 499 "cpp2regex.h2" +#line 611 "cpp2regex.h2" // Regex syntax: {min, max} Example: a{2,4} // template class range_token_matcher @@ -522,42 +610,42 @@ template class range_tok public: template [[nodiscard]] static auto match(Iter const& cur, auto& ctx, auto const& inner, auto const& reset_func, auto const& end_func, auto const& tail) -> auto; -#line 517 "cpp2regex.h2" +#line 629 "cpp2regex.h2" private: [[nodiscard]] static auto is_below_upper_bound(cpp2::impl::in count) -> bool; -#line 522 "cpp2regex.h2" +#line 634 "cpp2regex.h2" private: [[nodiscard]] static auto is_below_lower_bound(cpp2::impl::in count) -> bool; -#line 527 "cpp2regex.h2" +#line 639 "cpp2regex.h2" private: [[nodiscard]] static auto is_in_range(cpp2::impl::in count) -> bool; -#line 533 "cpp2regex.h2" +#line 645 "cpp2regex.h2" private: template [[nodiscard]] static auto match_min_count(Iter const& cur, auto& ctx, auto const& inner, auto const& end_func, int& count_r) -> auto; -#line 549 "cpp2regex.h2" +#line 661 "cpp2regex.h2" private: template [[nodiscard]] static auto match_greedy(cpp2::impl::in count, Iter const& cur, Iter const& last_valid, auto& ctx, auto const& inner, auto const& reset_func, auto const& end_func, auto const& other) -> match_return; -#line 579 "cpp2regex.h2" +#line 691 "cpp2regex.h2" private: template [[nodiscard]] static auto match_possessive(Iter const& cur, auto& ctx, auto const& inner, auto const& end_func, auto const& other) -> match_return; -#line 607 "cpp2regex.h2" +#line 719 "cpp2regex.h2" private: template [[nodiscard]] static auto match_not_greedy(Iter const& cur, auto& ctx, auto const& inner, auto const& end_func, auto const& other) -> match_return; public: range_token_matcher() = default; public: range_token_matcher(range_token_matcher const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(range_token_matcher const&) -> void = delete; -#line 633 "cpp2regex.h2" +#line 745 "cpp2regex.h2" }; -#line 636 "cpp2regex.h2" +#line 748 "cpp2regex.h2" // Regex syntax: \b or \B Example: \bword\b // // Matches the start end end of word boundaries. // template [[nodiscard]] auto word_boundary_token_matcher(auto& cur, auto& ctx) -> bool; -#line 665 "cpp2regex.h2" +#line 777 "cpp2regex.h2" //----------------------------------------------------------------------- // // Regular expression implementation. @@ -566,10 +654,9 @@ template [[nodiscard]] auto word_boundary_token_mat // // Regular expression implementation -template class regular_expression +template class regular_expression { - public: template using matcher = matcher_wrapper_type;// TODO: Remove when nested types are allowed: https://github.com/hsutter/cppfront/issues/727 - public: template using context = matcher_context_type>;// TODO: Remove when nested types are allowed: https://github.com/hsutter/cppfront/issues/727 + public: template using context = matcher_context_type;// TODO: Remove when nested types are allowed: https://github.com/hsutter/cppfront/issues/727 public: template class search_return { @@ -579,7 +666,10 @@ template class regular_expression public: search_return(cpp2::impl::in matched_, context const& ctx_, Iter const& pos_); -#line 690 "cpp2regex.h2" +#line 801 "cpp2regex.h2" + public: search_return(Iter const& begin, Iter const& end); + +#line 807 "cpp2regex.h2" public: [[nodiscard]] auto group_number() const& -> decltype(auto); public: [[nodiscard]] auto group(cpp2::impl::in g) const& -> decltype(auto); public: [[nodiscard]] auto group_start(cpp2::impl::in g) const& -> decltype(auto); @@ -589,26 +679,38 @@ template class regular_expression public: [[nodiscard]] auto group_start(cpp2::impl::in> g) const& -> decltype(auto); public: [[nodiscard]] auto group_end(cpp2::impl::in> g) const& -> decltype(auto); + public: auto update(cpp2::impl::in> r) & -> void; + +#line 821 "cpp2regex.h2" private: [[nodiscard]] auto get_group_id(cpp2::impl::in> g) const& -> auto; public: search_return(search_return const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(search_return const&) -> void = delete; -#line 706 "cpp2regex.h2" +#line 828 "cpp2regex.h2" }; + public: [[nodiscard]] auto find_all(auto&& func, cpp2::impl::in> str) const& -> decltype(auto); + public: [[nodiscard]] auto find_all(auto&& func, cpp2::impl::in> str, cpp2::impl::in start) const& -> decltype(auto); + public: [[nodiscard]] auto find_all(auto&& func, cpp2::impl::in> str, cpp2::impl::in start, cpp2::impl::in length) const& -> decltype(auto); + public: template auto find_all(auto const& func, Iter const& start, Iter const& end) const& -> void; + +#line 861 "cpp2regex.h2" public: [[nodiscard]] auto match(cpp2::impl::in> str) const& -> decltype(auto); public: [[nodiscard]] auto match(cpp2::impl::in> str, auto const& start) const& -> decltype(auto); public: [[nodiscard]] auto match(cpp2::impl::in> str, auto const& start, auto const& length) const& -> decltype(auto); public: template [[nodiscard]] auto match(Iter const& start, Iter const& end) const& -> search_return; -#line 719 "cpp2regex.h2" +#line 872 "cpp2regex.h2" public: [[nodiscard]] auto search(cpp2::impl::in> str) const& -> decltype(auto); public: [[nodiscard]] auto search(cpp2::impl::in> str, auto const& start) const& -> decltype(auto); public: [[nodiscard]] auto search(cpp2::impl::in> str, auto const& start, auto const& length) const& -> decltype(auto); public: template [[nodiscard]] auto search(Iter const& start, Iter const& end) const& -> search_return; -#line 742 "cpp2regex.h2" +#line 882 "cpp2regex.h2" + private: template [[nodiscard]] auto search_with_context(context& ctx, Iter const& start) const& -> match_return; + +#line 907 "cpp2regex.h2" public: [[nodiscard]] auto to_string() const& -> decltype(auto); // Helper functions @@ -619,7 +721,7 @@ template class regular_expression public: auto operator=(regular_expression const&) -> void = delete; -#line 754 "cpp2regex.h2" +#line 919 "cpp2regex.h2" }; } @@ -631,7 +733,7 @@ template class regular_expression #line 1 "cpp2regex.h2" -#line 22 "cpp2regex.h2" +#line 20 "cpp2regex.h2" namespace cpp2 { namespace regex { @@ -646,55 +748,60 @@ template match_return::match_return(auto const& matched_, , pos{ pos_ }{} template match_return::match_return(){} -#line 63 "cpp2regex.h2" +#line 61 "cpp2regex.h2" template match_context::match_context(Iter const& begin_, Iter const& end_) : begin{ begin_ } , end{ end_ }{ -#line 66 "cpp2regex.h2" +#line 64 "cpp2regex.h2" } -#line 68 "cpp2regex.h2" +#line 66 "cpp2regex.h2" template match_context::match_context(match_context const& that) : begin{ that.begin } , end{ that.end } , groups{ that.groups }{} -#line 68 "cpp2regex.h2" +#line 66 "cpp2regex.h2" template auto match_context::operator=(match_context const& that) -> match_context& { begin = that.begin; end = that.end; groups = that.groups; return *this; } -#line 68 "cpp2regex.h2" +#line 66 "cpp2regex.h2" template match_context::match_context(match_context&& that) noexcept : begin{ std::move(that).begin } , end{ std::move(that).end } , groups{ std::move(that).groups }{} -#line 68 "cpp2regex.h2" +#line 66 "cpp2regex.h2" template auto match_context::operator=(match_context&& that) noexcept -> match_context& { begin = std::move(that).begin; end = std::move(that).end; groups = std::move(that).groups; return *this; } -#line 72 "cpp2regex.h2" +#line 70 "cpp2regex.h2" + template [[nodiscard]] auto match_context::get_string_start() const& -> decltype(auto) { return begin; } +#line 71 "cpp2regex.h2" + template [[nodiscard]] auto match_context::get_string_end() const& -> decltype(auto) { return end; } + +#line 75 "cpp2regex.h2" template [[nodiscard]] auto match_context::get_group(auto const& group) const& -> decltype(auto) { return CPP2_ASSERT_IN_BOUNDS(groups, group); } -#line 74 "cpp2regex.h2" +#line 77 "cpp2regex.h2" template [[nodiscard]] auto match_context::get_group_end(auto const& group) const& -> int{ if (cpp2::impl::cmp_greater_eq(group,max_groups) || !(CPP2_ASSERT_IN_BOUNDS(groups, group).matched)) { return 0; } return cpp2::unchecked_narrow(std::distance(begin, CPP2_ASSERT_IN_BOUNDS(groups, group).end)); } -#line 80 "cpp2regex.h2" +#line 83 "cpp2regex.h2" template [[nodiscard]] auto match_context::get_group_start(auto const& group) const& -> int{ if (cpp2::impl::cmp_greater_eq(group,max_groups) || !(CPP2_ASSERT_IN_BOUNDS(groups, group).matched)) { return 0; } return cpp2::unchecked_narrow(std::distance(begin, CPP2_ASSERT_IN_BOUNDS(groups, group).start)); } -#line 86 "cpp2regex.h2" +#line 89 "cpp2regex.h2" template [[nodiscard]] auto match_context::get_group_string(auto const& group) const& -> std::string{ if (cpp2::impl::cmp_greater_eq(group,max_groups) || !(CPP2_ASSERT_IN_BOUNDS(groups, group).matched)) { return ""; @@ -702,97 +809,199 @@ template match_return::match_return(){} return std::string(CPP2_ASSERT_IN_BOUNDS(groups, group).start, CPP2_ASSERT_IN_BOUNDS(groups, group).end); } -#line 93 "cpp2regex.h2" +#line 96 "cpp2regex.h2" template auto match_context::set_group_end(auto const& group, auto const& pos) & -> void{ CPP2_ASSERT_IN_BOUNDS(groups, group).end = pos; CPP2_ASSERT_IN_BOUNDS(groups, group).matched = true; } -#line 98 "cpp2regex.h2" +#line 101 "cpp2regex.h2" template auto match_context::set_group_invalid(auto const& group) & -> void{ CPP2_ASSERT_IN_BOUNDS(groups, group).matched = false; } -#line 102 "cpp2regex.h2" +#line 105 "cpp2regex.h2" template auto match_context::set_group_start(auto const& group, auto const& pos) & -> void{ CPP2_ASSERT_IN_BOUNDS(groups, group).start = pos; } -#line 106 "cpp2regex.h2" +#line 109 "cpp2regex.h2" template [[nodiscard]] auto match_context::size() const& -> decltype(auto) { return max_groups; } -#line 110 "cpp2regex.h2" +#line 113 "cpp2regex.h2" template [[nodiscard]] auto match_context::fail() const& -> decltype(auto) { return match_return(false, end); } -#line 111 "cpp2regex.h2" +#line 114 "cpp2regex.h2" template [[nodiscard]] auto match_context::pass(cpp2::impl::in cur) const& -> decltype(auto) { return match_return(true, cur); } -#line 119 "cpp2regex.h2" +#line 116 "cpp2regex.h2" + template auto match_context::reset() & -> void{ + for ( auto& g : groups ) { + g.matched = false; + } + } + +#line 133 "cpp2regex.h2" + template reverse_match_context::reverse_match_context(auto const& forward_context_) + : forward_context{ forward_context_ } + , begin{ std::make_reverse_iterator((*cpp2::impl::assert_not_null(forward_context)).end) } + , end{ std::make_reverse_iterator((*cpp2::impl::assert_not_null(forward_context)).begin) }{ + +#line 137 "cpp2regex.h2" + } +#line 133 "cpp2regex.h2" + template auto reverse_match_context::operator=(auto const& forward_context_) -> reverse_match_context& { + forward_context = forward_context_; + begin = std::make_reverse_iterator((*cpp2::impl::assert_not_null(forward_context)).end); + end = std::make_reverse_iterator((*cpp2::impl::assert_not_null(forward_context)).begin); + return *this; + +#line 137 "cpp2regex.h2" + } + +#line 139 "cpp2regex.h2" + template reverse_match_context::reverse_match_context(reverse_match_context const& that) + : forward_context{ that.forward_context } + , begin{ that.begin } + , end{ that.end }{} +#line 139 "cpp2regex.h2" + template auto reverse_match_context::operator=(reverse_match_context const& that) -> reverse_match_context& { + forward_context = that.forward_context; + begin = that.begin; + end = that.end; + return *this; } +#line 139 "cpp2regex.h2" + template reverse_match_context::reverse_match_context(reverse_match_context&& that) noexcept + : forward_context{ std::move(that).forward_context } + , begin{ std::move(that).begin } + , end{ std::move(that).end }{} +#line 139 "cpp2regex.h2" + template auto reverse_match_context::operator=(reverse_match_context&& that) noexcept -> reverse_match_context& { + forward_context = std::move(that).forward_context; + begin = std::move(that).begin; + end = std::move(that).end; + return *this; } + +#line 143 "cpp2regex.h2" + template [[nodiscard]] auto reverse_match_context::get_string_start() const& -> decltype(auto) { return end; } +#line 144 "cpp2regex.h2" + template [[nodiscard]] auto reverse_match_context::get_string_end() const& -> decltype(auto) { return begin; } + +#line 148 "cpp2regex.h2" + template auto reverse_match_context::set_group_end(auto const& group, auto const& pos) & -> void{ + (*cpp2::impl::assert_not_null(forward_context)).set_group_end(group, CPP2_UFCS(base)((pos))); + } + +#line 152 "cpp2regex.h2" + template auto reverse_match_context::set_group_invalid(auto const& group) & -> void{ + (*cpp2::impl::assert_not_null(forward_context)).set_group_invalid(group); + } + +#line 156 "cpp2regex.h2" + template auto reverse_match_context::set_group_start(auto const& group, auto const& pos) & -> void{ + (*cpp2::impl::assert_not_null(forward_context)).set_group_start(group, CPP2_UFCS(base)((pos))); + } + +#line 162 "cpp2regex.h2" + template [[nodiscard]] auto reverse_match_context::fail() const& -> decltype(auto) { return match_return(false, end); } +#line 163 "cpp2regex.h2" + template [[nodiscard]] auto reverse_match_context::pass(cpp2::impl::in cur) const& -> decltype(auto) { return match_return(true, cur); } + +#line 168 "cpp2regex.h2" +template [[nodiscard]] auto make_forward_match_context(match_context& ctx) -> decltype(auto){ + return ctx; +} + +#line 172 "cpp2regex.h2" +template [[nodiscard]] auto make_forward_match_context(reverse_match_context& ctx) -> decltype(auto){ + return *cpp2::impl::assert_not_null(ctx.forward_context); +} + +#line 176 "cpp2regex.h2" +template [[nodiscard]] auto make_reverse_match_context(match_context& ctx) -> auto{ + return reverse_match_context(&ctx); +} + +#line 180 "cpp2regex.h2" +template [[nodiscard]] auto make_reverse_match_context(reverse_match_context& ctx) -> decltype(auto){ + return ctx; +} + +#line 186 "cpp2regex.h2" +template [[nodiscard]] auto make_forward_iterator(Iter const& pos) -> auto { return pos; } +#line 187 "cpp2regex.h2" +template [[nodiscard]] auto make_forward_iterator(std::reverse_iterator const& pos) -> auto { return CPP2_UFCS(base)(pos); } +#line 188 "cpp2regex.h2" +template [[nodiscard]] auto make_reverse_iterator(Iter const& pos) -> auto { return std::make_reverse_iterator(pos); } +#line 189 "cpp2regex.h2" +template [[nodiscard]] auto make_reverse_iterator(std::reverse_iterator const& pos) -> auto { return pos; } + +#line 196 "cpp2regex.h2" [[nodiscard]] auto true_end_func::operator()(auto const& cur, auto& ctx) const& -> decltype(auto) { return ctx.pass(cur); } -#line 127 "cpp2regex.h2" +#line 204 "cpp2regex.h2" auto no_reset::operator()([[maybe_unused]] auto& unnamed_param_2) const& -> void{} -#line 136 "cpp2regex.h2" +#line 213 "cpp2regex.h2" template on_return::on_return(Func const& f) : func{ f }{ -#line 138 "cpp2regex.h2" +#line 215 "cpp2regex.h2" } -#line 136 "cpp2regex.h2" +#line 213 "cpp2regex.h2" template auto on_return::operator=(Func const& f) -> on_return& { func = f; return *this; -#line 138 "cpp2regex.h2" +#line 215 "cpp2regex.h2" } -#line 140 "cpp2regex.h2" +#line 217 "cpp2regex.h2" template on_return::~on_return() noexcept{ cpp2::move(*this).func(); } -#line 147 "cpp2regex.h2" +#line 224 "cpp2regex.h2" template [[nodiscard]] auto make_on_return(Func const& func) -> decltype(auto) { return on_return(func); } -#line 161 "cpp2regex.h2" +#line 238 "cpp2regex.h2" template [[nodiscard]] auto single_class_entry::includes(cpp2::impl::in c) -> decltype(auto) { return c == C; } -#line 162 "cpp2regex.h2" +#line 239 "cpp2regex.h2" template [[nodiscard]] auto single_class_entry::to_string() -> decltype(auto) { return bstring(1, C); } -#line 170 "cpp2regex.h2" +#line 247 "cpp2regex.h2" template [[nodiscard]] auto range_class_entry::includes(cpp2::impl::in c) -> decltype(auto) { return [_0 = Start, _1 = c, _2 = End]{ return cpp2::impl::cmp_less_eq(_0,_1) && cpp2::impl::cmp_less_eq(_1,_2); }(); } -#line 171 "cpp2regex.h2" +#line 248 "cpp2regex.h2" template [[nodiscard]] auto range_class_entry::to_string() -> decltype(auto) { return "" + cpp2::to_string(Start) + "-" + cpp2::to_string(End) + ""; } -#line 179 "cpp2regex.h2" +#line 256 "cpp2regex.h2" template [[nodiscard]] auto combined_class_entry::includes(cpp2::impl::in c) -> decltype(auto) { return (false || ... || List::includes(c)); } -#line 180 "cpp2regex.h2" +#line 257 "cpp2regex.h2" template [[nodiscard]] auto combined_class_entry::to_string() -> decltype(auto) { return (bstring() + ... + List::to_string()); } -#line 188 "cpp2regex.h2" +#line 265 "cpp2regex.h2" template [[nodiscard]] auto list_class_entry::includes(cpp2::impl::in c) -> decltype(auto) { return (false || ... || (List == c)); } -#line 189 "cpp2regex.h2" +#line 266 "cpp2regex.h2" template [[nodiscard]] auto list_class_entry::to_string() -> decltype(auto) { return (bstring() + ... + List); } -#line 197 "cpp2regex.h2" +#line 274 "cpp2regex.h2" template [[nodiscard]] auto named_class_entry::includes(cpp2::impl::in c) -> decltype(auto) { return Inner::includes(c); } -#line 198 "cpp2regex.h2" +#line 275 "cpp2regex.h2" template [[nodiscard]] auto named_class_entry::to_string() -> decltype(auto) { return "[:" + cpp2::to_string(Name.data()) + ":]"; } -#line 205 "cpp2regex.h2" +#line 282 "cpp2regex.h2" template [[nodiscard]] auto negated_class_entry::includes(cpp2::impl::in c) -> decltype(auto) { return !(Inner::includes(c)); } -#line 213 "cpp2regex.h2" +#line 290 "cpp2regex.h2" template [[nodiscard]] auto shorthand_class_entry::includes(cpp2::impl::in c) -> decltype(auto) { return Inner::includes(c); } -#line 214 "cpp2regex.h2" +#line 291 "cpp2regex.h2" template [[nodiscard]] auto shorthand_class_entry::to_string() -> decltype(auto) { return Name.str(); } -#line 261 "cpp2regex.h2" +#line 338 "cpp2regex.h2" template [[nodiscard]] auto alternative_token_matcher::match(auto const& cur, auto& ctx, auto const& end_func, auto const& tail, auto const& ...functions) -> auto{ return match_first(cur, ctx, end_func, tail, functions...); } -#line 265 "cpp2regex.h2" +#line 342 "cpp2regex.h2" template template [[nodiscard]] auto alternative_token_matcher::match_first(auto const& cur, auto& ctx, auto const& end_func, auto const& tail, auto const& cur_func, auto const& cur_reset, Other const& ...other) -> auto { auto inner_call {[_0 = (tail), _1 = (end_func)](auto const& tail_cur, auto& tail_ctx) -> auto{ @@ -812,7 +1021,7 @@ template [[nodiscard]] auto make_on_return(Func const& func) -> d } } -#line 288 "cpp2regex.h2" +#line 365 "cpp2regex.h2" template [[nodiscard]] auto any_token_matcher(auto& cur, auto& ctx) -> bool { if ( cur != ctx.end // any char except the end @@ -825,7 +1034,19 @@ template [[nodiscard]] auto any_token_matcher( return false; } -#line 339 "cpp2regex.h2" +#line 379 "cpp2regex.h2" +template [[nodiscard]] auto atomic_group_matcher(Iter const& cur, auto& ctx, auto const& inner, auto const& end_func, auto const& other) -> auto +{ + auto r {inner(cur, ctx, true_end_func())}; + + if (r.matched) { + r = other(r.pos, ctx, end_func); + } + + return r; +} + +#line 429 "cpp2regex.h2" template [[nodiscard]] auto class_token_matcher::match(auto& cur, auto& ctx) -> bool { if constexpr (case_insensitive) @@ -855,7 +1076,7 @@ template [[nodiscard]] auto any_token_matcher( } } -#line 368 "cpp2regex.h2" +#line 458 "cpp2regex.h2" template template [[nodiscard]] auto class_token_matcher::match_any(cpp2::impl::in c) -> bool { bool r {First::includes(c)}; @@ -869,16 +1090,24 @@ template [[nodiscard]] auto any_token_matcher( return r; } -#line 417 "cpp2regex.h2" -template [[nodiscard]] auto group_ref_token_matcher(auto& cur, auto& ctx) -> bool +#line 507 "cpp2regex.h2" +template [[nodiscard]] auto group_ref_token_matcher(auto& cur, auto& ctx) -> bool { auto g {ctx.get_group(group)}; - auto group_pos {cpp2::move(g).start}; + auto group_pos {g.start}; + auto group_end {g.end}; + int group_inc {1}; + if (reverse) { + group_pos = g.end; + group_end = cpp2::move(g).start; + group_inc = -1; + } + for( ; - group_pos != g.end + group_pos != group_end && cur != ctx.end; - (++group_pos, ++cur) ) + (group_pos += group_inc, ++cur) ) { if constexpr (case_insensitive) { if (string_util::safe_tolower(*cpp2::impl::assert_not_null(group_pos)) != string_util::safe_tolower(*cpp2::impl::assert_not_null(cur))) { @@ -892,7 +1121,7 @@ template [[nodiscard]] auto gr } } - if (cpp2::move(group_pos) == cpp2::move(g).end) { + if (cpp2::move(group_pos) == cpp2::move(group_end)) { return true; } else { @@ -900,13 +1129,13 @@ template [[nodiscard]] auto gr } } -#line 450 "cpp2regex.h2" +#line 548 "cpp2regex.h2" template [[nodiscard]] auto line_end_token_matcher(auto const& cur, auto& ctx) -> bool { - if (cur == ctx.end || (match_new_line && *cpp2::impl::assert_not_null(cur) == '\n')) { + if (cur == CPP2_UFCS(get_string_end)(ctx) || (match_new_line && *cpp2::impl::assert_not_null(cur) == '\n')) { return true; } - else {if (match_new_line_before_end && (*cpp2::impl::assert_not_null(cur) == '\n' && (cur + 1) == ctx.end)) {// Special case for new line at end. + else {if (match_new_line_before_end && (*cpp2::impl::assert_not_null(cur) == '\n' && (cur + 1) == CPP2_UFCS(get_string_end)(ctx))) {// Special case for new line at end. return true; } else { @@ -914,17 +1143,17 @@ template [[ }} } -#line 466 "cpp2regex.h2" +#line 564 "cpp2regex.h2" template [[nodiscard]] auto line_start_token_matcher(auto const& cur, auto& ctx) -> bool { - return cur == ctx.begin || // Start of string + return cur == CPP2_UFCS(get_string_start)(ctx) || // Start of string (match_new_line && *cpp2::impl::assert_not_null((cur - 1)) == '\n'); // Start of new line } -#line 477 "cpp2regex.h2" +#line 575 "cpp2regex.h2" template [[nodiscard]] auto lookahead_token_matcher(auto const& cur, auto& ctx, auto const& func) -> bool { - auto r {func(cur, ctx, true_end_func())}; + auto r {func(make_forward_iterator(cur), make_forward_match_context(ctx), true_end_func())}; if (!(positive)) { r.matched = !(r.matched); } @@ -932,12 +1161,23 @@ template [[nodiscard]] auto lookahead_token_match return cpp2::move(r).matched; } -#line 493 "cpp2regex.h2" +#line 589 "cpp2regex.h2" +template [[nodiscard]] auto lookbehind_token_matcher(auto const& cur, auto& ctx, auto const& func) -> bool +{ + auto r {func(make_reverse_iterator(cur), make_reverse_match_context(ctx), true_end_func())}; + if (!(positive)) { + r.matched = !(r.matched); + } + + return cpp2::move(r).matched; +} + +#line 605 "cpp2regex.h2" inline CPP2_CONSTEXPR int range_flags::not_greedy{ 1 }; inline CPP2_CONSTEXPR int range_flags::greedy{ 2 }; inline CPP2_CONSTEXPR int range_flags::possessive{ 3 }; -#line 504 "cpp2regex.h2" +#line 616 "cpp2regex.h2" template template [[nodiscard]] auto range_token_matcher::match(Iter const& cur, auto& ctx, auto const& inner, auto const& reset_func, auto const& end_func, auto const& tail) -> auto { if (range_flags::possessive == kind) { @@ -951,26 +1191,26 @@ template [[nodiscard]] auto lookahead_token_match }} } -#line 517 "cpp2regex.h2" +#line 629 "cpp2regex.h2" template [[nodiscard]] auto range_token_matcher::is_below_upper_bound(cpp2::impl::in count) -> bool{ if (-1 == max_count) {return true; } else {return cpp2::impl::cmp_less(count,max_count); } } -#line 522 "cpp2regex.h2" +#line 634 "cpp2regex.h2" template [[nodiscard]] auto range_token_matcher::is_below_lower_bound(cpp2::impl::in count) -> bool{ if (-1 == min_count) {return false; } else {return cpp2::impl::cmp_less(count,min_count); } } -#line 527 "cpp2regex.h2" +#line 639 "cpp2regex.h2" template [[nodiscard]] auto range_token_matcher::is_in_range(cpp2::impl::in count) -> bool{ if (-1 != min_count && cpp2::impl::cmp_less(count,min_count)) {return false; } if (-1 != max_count && cpp2::impl::cmp_greater(count,max_count)) {return false; } return true; } -#line 533 "cpp2regex.h2" +#line 645 "cpp2regex.h2" template template [[nodiscard]] auto range_token_matcher::match_min_count(Iter const& cur, auto& ctx, auto const& inner, auto const& end_func, int& count_r) -> auto { // TODO: count_r as out parameter introduces a performance loss. auto res {ctx.pass(cur)}; @@ -987,7 +1227,7 @@ template [[nodiscard]] auto lookahead_token_match return res; } -#line 549 "cpp2regex.h2" +#line 661 "cpp2regex.h2" template template [[nodiscard]] auto range_token_matcher::match_greedy(cpp2::impl::in count, Iter const& cur, Iter const& last_valid, auto& ctx, auto const& inner, auto const& reset_func, auto const& end_func, auto const& other) -> match_return { auto inner_call {[_0 = (count + 1), _1 = (cur), _2 = (inner), _3 = (reset_func), _4 = (end_func), _5 = (other)](auto const& tail_cur, auto& tail_ctx) -> auto{ @@ -1018,7 +1258,7 @@ template [[nodiscard]] auto lookahead_token_match return r; } -#line 579 "cpp2regex.h2" +#line 691 "cpp2regex.h2" template template [[nodiscard]] auto range_token_matcher::match_possessive(Iter const& cur, auto& ctx, auto const& inner, auto const& end_func, auto const& other) -> match_return { auto count {0}; @@ -1047,7 +1287,7 @@ template [[nodiscard]] auto lookahead_token_match return other(cpp2::move(pos), ctx, end_func); } -#line 607 "cpp2regex.h2" +#line 719 "cpp2regex.h2" template template [[nodiscard]] auto range_token_matcher::match_not_greedy(Iter const& cur, auto& ctx, auto const& inner, auto const& end_func, auto const& other) -> match_return { auto count {0}; @@ -1075,20 +1315,20 @@ template [[nodiscard]] auto lookahead_token_match return other(cpp2::move(pos), ctx, end_func); // Upper bound reached. } -#line 640 "cpp2regex.h2" +#line 752 "cpp2regex.h2" template [[nodiscard]] auto word_boundary_token_matcher(auto& cur, auto& ctx) -> bool { word_class words {}; auto is_match {false}; - if (cur == ctx.begin) {// String start + if (cur == ctx.begin) {// Iteration start if (cur != ctx.end) {// No empty string is_match = cpp2::move(words).includes(*cpp2::impl::assert_not_null(cur)); } } - else {if (cur == ctx.end) {// String end + else {if (cur == ctx.end) {// Iteration end is_match = cpp2::move(words).includes(*cpp2::impl::assert_not_null((cur - 1))); } - else { // Middle of string + else { // Middle of iteration is_match = (words.includes(*cpp2::impl::assert_not_null((cur - 1))) && !(words.includes(*cpp2::impl::assert_not_null(cur)))) // End of word: \w\W || (!(words.includes(*cpp2::impl::assert_not_null((cur - 1)))) && words.includes(*cpp2::impl::assert_not_null(cur)));// Start of word: \W\w @@ -1100,70 +1340,127 @@ template [[nodiscard]] auto word_boundary_token_mat return is_match; } -#line 684 "cpp2regex.h2" - template template regular_expression::search_return::search_return(cpp2::impl::in matched_, context const& ctx_, Iter const& pos_) +#line 795 "cpp2regex.h2" + template template regular_expression::search_return::search_return(cpp2::impl::in matched_, context const& ctx_, Iter const& pos_) : matched{ matched_ } , ctx{ ctx_ } , pos{ cpp2::unchecked_narrow(std::distance(ctx_.begin, pos_)) }{ -#line 688 "cpp2regex.h2" +#line 799 "cpp2regex.h2" } -#line 690 "cpp2regex.h2" - template template [[nodiscard]] auto regular_expression::search_return::group_number() const& -> decltype(auto) { return ctx.size(); } -#line 691 "cpp2regex.h2" - template template [[nodiscard]] auto regular_expression::search_return::group(cpp2::impl::in g) const& -> decltype(auto) { return ctx.get_group_string(g); } -#line 692 "cpp2regex.h2" - template template [[nodiscard]] auto regular_expression::search_return::group_start(cpp2::impl::in g) const& -> decltype(auto) { return ctx.get_group_start(g); } -#line 693 "cpp2regex.h2" - template template [[nodiscard]] auto regular_expression::search_return::group_end(cpp2::impl::in g) const& -> decltype(auto) { return ctx.get_group_end(g); } - -#line 695 "cpp2regex.h2" - template template [[nodiscard]] auto regular_expression::search_return::group(cpp2::impl::in> g) const& -> decltype(auto) { return group(get_group_id(g)); } -#line 696 "cpp2regex.h2" - template template [[nodiscard]] auto regular_expression::search_return::group_start(cpp2::impl::in> g) const& -> decltype(auto) { return group_start(get_group_id(g)); } -#line 697 "cpp2regex.h2" - template template [[nodiscard]] auto regular_expression::search_return::group_end(cpp2::impl::in> g) const& -> decltype(auto) { return group_end(get_group_id(g)); } - -#line 699 "cpp2regex.h2" - template template [[nodiscard]] auto regular_expression::search_return::get_group_id(cpp2::impl::in> g) const& -> auto{ - auto group_id {matcher::get_named_group_index(g)}; +#line 801 "cpp2regex.h2" + template template regular_expression::search_return::search_return(Iter const& begin, Iter const& end) + : matched{ false } + , ctx{ begin, end } + , pos{ 0 }{ + +#line 805 "cpp2regex.h2" + } + +#line 807 "cpp2regex.h2" + template template [[nodiscard]] auto regular_expression::search_return::group_number() const& -> decltype(auto) { return ctx.size(); } +#line 808 "cpp2regex.h2" + template template [[nodiscard]] auto regular_expression::search_return::group(cpp2::impl::in g) const& -> decltype(auto) { return ctx.get_group_string(g); } +#line 809 "cpp2regex.h2" + template template [[nodiscard]] auto regular_expression::search_return::group_start(cpp2::impl::in g) const& -> decltype(auto) { return ctx.get_group_start(g); } +#line 810 "cpp2regex.h2" + template template [[nodiscard]] auto regular_expression::search_return::group_end(cpp2::impl::in g) const& -> decltype(auto) { return ctx.get_group_end(g); } + +#line 812 "cpp2regex.h2" + template template [[nodiscard]] auto regular_expression::search_return::group(cpp2::impl::in> g) const& -> decltype(auto) { return group(get_group_id(g)); } +#line 813 "cpp2regex.h2" + template template [[nodiscard]] auto regular_expression::search_return::group_start(cpp2::impl::in> g) const& -> decltype(auto) { return group_start(get_group_id(g)); } +#line 814 "cpp2regex.h2" + template template [[nodiscard]] auto regular_expression::search_return::group_end(cpp2::impl::in> g) const& -> decltype(auto) { return group_end(get_group_id(g)); } + +#line 816 "cpp2regex.h2" + template template auto regular_expression::search_return::update(cpp2::impl::in> r) & -> void{ + matched = r.matched; + pos = cpp2::unchecked_narrow(std::distance(ctx.begin, r.pos)); + } + +#line 821 "cpp2regex.h2" + template template [[nodiscard]] auto regular_expression::search_return::get_group_id(cpp2::impl::in> g) const& -> auto{ + auto group_id {matcher::get_named_group_index(g)}; if (-1 == group_id) { // TODO: Throw error. } return group_id; } -#line 708 "cpp2regex.h2" - template [[nodiscard]] auto regular_expression::match(cpp2::impl::in> str) const& -> decltype(auto) { return match(str.begin(), str.end()); } -#line 709 "cpp2regex.h2" - template [[nodiscard]] auto regular_expression::match(cpp2::impl::in> str, auto const& start) const& -> decltype(auto) { return match(get_iter(str, start), str.end()); } -#line 710 "cpp2regex.h2" - template [[nodiscard]] auto regular_expression::match(cpp2::impl::in> str, auto const& start, auto const& length) const& -> decltype(auto) { return match(get_iter(str, start), get_iter(str, start + length)); } -#line 711 "cpp2regex.h2" - template template [[nodiscard]] auto regular_expression::match(Iter const& start, Iter const& end) const& -> search_return +#line 830 "cpp2regex.h2" + template [[nodiscard]] auto regular_expression::find_all(auto&& func, cpp2::impl::in> str) const& -> decltype(auto) { return find_all(CPP2_FORWARD(func), str.begin(), str.end()); } +#line 831 "cpp2regex.h2" + template [[nodiscard]] auto regular_expression::find_all(auto&& func, cpp2::impl::in> str, cpp2::impl::in start) const& -> decltype(auto) { return find_all(CPP2_FORWARD(func), get_iter(str, start), str.end()); } +#line 832 "cpp2regex.h2" + template [[nodiscard]] auto regular_expression::find_all(auto&& func, cpp2::impl::in> str, cpp2::impl::in start, cpp2::impl::in length) const& -> decltype(auto) { return find_all(CPP2_FORWARD(func), get_iter(str, start), get_iter(str, start + length)); } +#line 833 "cpp2regex.h2" + template template auto regular_expression::find_all(auto const& func, Iter const& start, Iter const& end) const& -> void + { + auto sr {search_return(start, end)}; + auto cont {true}; + auto cur {start}; + + while( cont ) { + auto r {search_with_context(sr.ctx, cur)}; + cont = r.matched; // First update the continue so that the user can override it. + + if (r.matched) { + sr.update(cpp2::move(r)); + cont = func(sr); + } + + if (cont) { + // Prevent infinity loop for zero length match. + cont = 0 != sr.ctx.get_group_end(0) - sr.ctx.get_group_start(0); + } + + // Check now if to continue, user may override + if (cont) { + cur = start + sr.ctx.get_group_end(0); + CPP2_UFCS(reset)(sr.ctx); + } + } + } + +#line 861 "cpp2regex.h2" + template [[nodiscard]] auto regular_expression::match(cpp2::impl::in> str) const& -> decltype(auto) { return match(str.begin(), str.end()); } +#line 862 "cpp2regex.h2" + template [[nodiscard]] auto regular_expression::match(cpp2::impl::in> str, auto const& start) const& -> decltype(auto) { return match(get_iter(str, start), str.end()); } +#line 863 "cpp2regex.h2" + template [[nodiscard]] auto regular_expression::match(cpp2::impl::in> str, auto const& start, auto const& length) const& -> decltype(auto) { return match(get_iter(str, start), get_iter(str, start + length)); } +#line 864 "cpp2regex.h2" + template template [[nodiscard]] auto regular_expression::match(Iter const& start, Iter const& end) const& -> search_return { context ctx {start, end}; - auto r {matcher::entry(start, ctx)}; + auto r {matcher::entry(start, ctx)}; return search_return(r.matched && r.pos == end, cpp2::move(ctx), r.pos); } -#line 719 "cpp2regex.h2" - template [[nodiscard]] auto regular_expression::search(cpp2::impl::in> str) const& -> decltype(auto) { return search(str.begin(), str.end()); } -#line 720 "cpp2regex.h2" - template [[nodiscard]] auto regular_expression::search(cpp2::impl::in> str, auto const& start) const& -> decltype(auto) { return search(get_iter(str, start), str.end()); } -#line 721 "cpp2regex.h2" - template [[nodiscard]] auto regular_expression::search(cpp2::impl::in> str, auto const& start, auto const& length) const& -> decltype(auto) { return search(get_iter(str, start), get_iter(str, start + length)); } -#line 722 "cpp2regex.h2" - template template [[nodiscard]] auto regular_expression::search(Iter const& start, Iter const& end) const& -> search_return +#line 872 "cpp2regex.h2" + template [[nodiscard]] auto regular_expression::search(cpp2::impl::in> str) const& -> decltype(auto) { return search(str.begin(), str.end()); } +#line 873 "cpp2regex.h2" + template [[nodiscard]] auto regular_expression::search(cpp2::impl::in> str, auto const& start) const& -> decltype(auto) { return search(get_iter(str, start), str.end()); } +#line 874 "cpp2regex.h2" + template [[nodiscard]] auto regular_expression::search(cpp2::impl::in> str, auto const& start, auto const& length) const& -> decltype(auto) { return search(get_iter(str, start), get_iter(str, start + length)); } +#line 875 "cpp2regex.h2" + template template [[nodiscard]] auto regular_expression::search(Iter const& start, Iter const& end) const& -> search_return { context ctx {start, end}; + auto r {search_with_context(ctx, start)}; + return search_return(r.matched, cpp2::move(ctx), cpp2::move(r).pos); + } + +#line 882 "cpp2regex.h2" + template template [[nodiscard]] auto regular_expression::search_with_context(context& ctx, Iter const& start) const& -> match_return + { auto r {ctx.fail()}; auto cur {start}; for( ; true; (++cur) ) { - r = matcher::entry(cur, ctx); + r = matcher::entry(cur, ctx); if (r.matched) { break; } @@ -1171,16 +1468,20 @@ template [[nodiscard]] auto word_boundary_token_mat if (cur == ctx.end) { break; } + + if (matcher::is_start_match()) { + break; // Always break with \G option. + } } - return search_return(r.matched, cpp2::move(ctx), cpp2::move(r).pos); + return r; } -#line 742 "cpp2regex.h2" - template [[nodiscard]] auto regular_expression::to_string() const& -> decltype(auto) { return matcher_wrapper::to_string(); } +#line 907 "cpp2regex.h2" + template [[nodiscard]] auto regular_expression::to_string() const& -> decltype(auto) { return matcher::to_string(); } -#line 746 "cpp2regex.h2" - template [[nodiscard]] auto regular_expression::get_iter(cpp2::impl::in> str, auto const& pos) -> auto{ +#line 911 "cpp2regex.h2" + template [[nodiscard]] auto regular_expression::get_iter(cpp2::impl::in> str, auto const& pos) -> auto{ if (cpp2::impl::cmp_less(pos,str.size())) { return str.begin() + pos; } @@ -1189,7 +1490,7 @@ template [[nodiscard]] auto word_boundary_token_mat } } -#line 756 "cpp2regex.h2" +#line 921 "cpp2regex.h2" } } diff --git a/include/cpp2regex.h2 b/include/cpp2regex.h2 index 04b3add740..fcf5ec341a 100644 --- a/include/cpp2regex.h2 +++ b/include/cpp2regex.h2 @@ -13,11 +13,9 @@ #ifndef CPP2_CPP2REGEX_H #define CPP2_CPP2REGEX_H -template -using matcher_wrapper_type = typename matcher_wrapper::template wrap; -template -using matcher_context_type = typename matcher::context; +template +using matcher_context_type = typename matcher::template context; cpp2: namespace = { @@ -67,6 +65,11 @@ match_context: type = operator=: (out this, that) = {} + // String end and start positions + // + get_string_start: (in this) = begin; + get_string_end: (in this) = end; + // Getter and setter for groups // get_group: (in this, group) = groups[group]; @@ -109,8 +112,82 @@ match_context: type = // fail: (in this) = match_return(false, end); pass: (in this, cur: Iter) = match_return(true, cur); + + reset: (inout this) = { + for groups do (inout g) { + g.matched = false; + } + } +} + +// Wrapper of context for reverse matches. Implements only the minimal interface for matching. +// +reverse_match_context: type = +{ + public ReverseIter : type == std::reverse_iterator; + public forward_context : *match_context; + + public begin : ReverseIter; + public end : ReverseIter; + + operator=: (out this, forward_context_) = { + forward_context = forward_context_; + begin = std::make_reverse_iterator(forward_context*.end); + end = std::make_reverse_iterator(forward_context*.begin); + } + + operator=: (out this, that) = {} + + // String end and start positions + // + get_string_start: (in this) = end; + get_string_end: (in this) = begin; + + // Getter and setter for groups + // + set_group_end: (inout this, group, pos) = { + forward_context*..set_group_end(group, (pos).base()); + } + + set_group_invalid: (inout this, group) = { + forward_context*..set_group_invalid(group); + } + + set_group_start: (inout this, group, pos) = { + forward_context*..set_group_start(group, (pos).base()); + } + + // Misc functions + // + fail: (in this) = match_return(false, end); + pass: (in this, cur: ReverseIter) = match_return(true, cur); +} + +// Helpers for creating wrappers of the match context. +// +make_forward_match_context: (inout ctx: match_context) -> forward _ = { + return ctx; } +make_forward_match_context: (inout ctx: reverse_match_context) -> forward _ = { + return ctx.forward_context*; +} + +make_reverse_match_context: (inout ctx: match_context) -> _ = { + return reverse_match_context(ctx&); +} + +make_reverse_match_context: (inout ctx: reverse_match_context) -> forward _ = { + return ctx; +} + +// Helpers for creating wrappers of the iterators. +// +make_forward_iterator: (pos: Iter) -> _ = pos; +make_forward_iterator: (pos: std::reverse_iterator) -> _ = pos.base(); +make_reverse_iterator: (pos: Iter) -> _ = std::make_reverse_iterator(pos); +make_reverse_iterator: (pos: std::reverse_iterator) -> _ = pos; + // End function that returns a valid match. // @@ -297,6 +374,19 @@ any_token_matcher: (inout cur, inout ctx) -> bool = return false; } +// Regex syntax: (?>) Example: a(?>bc|c)c +// +atomic_group_matcher: (cur: Iter, inout ctx, inner, end_func, other) -> _ = +{ + r := inner(cur, ctx, true_end_func()); + + if r.matched { + r = other(r.pos, ctx, end_func); + } + + return r; +} + // TODO: Check if vectorization works at some point with this implementation. // char_token_matcher: (inout cur, inout ctx) -> bool = { @@ -414,15 +504,23 @@ named_class_not_word : type == class_token_ // \k // \k'name_or_number' // -group_ref_token_matcher: (inout cur, inout ctx) -> bool = +group_ref_token_matcher: (inout cur, inout ctx) -> bool = { g := ctx..get_group(group); group_pos := g.start; + group_end := g.end; + group_inc : int = 1; + if reverse { + group_pos = g.end; + group_end = g.start; + group_inc = -1; + } + while - group_pos != g.end + group_pos != group_end && cur != ctx.end - next (group_pos++, cur++) + next (group_pos += group_inc, cur++) { if constexpr case_insensitive { if string_util::safe_tolower(group_pos*) != string_util::safe_tolower(cur*) { @@ -436,7 +534,7 @@ group_ref_token_matcher: (inout cur, } } - if group_pos == g.end { + if group_pos == group_end { return true; } else { @@ -447,12 +545,12 @@ group_ref_token_matcher: (inout cur, // Regex syntax: $ Example: aa$ // -line_end_token_matcher: (cur, inout ctx) -> bool = +line_end_token_matcher: (cur, inout ctx) -> bool = { - if cur == ctx.end || (match_new_line && cur* == '\n') { + if cur == ctx.get_string_end() || (match_new_line && cur* == '\n') { return true; } - else if match_new_line_before_end && (cur* == '\n' && (cur + 1) == ctx.end) { // Special case for new line at end. + else if match_new_line_before_end && (cur* == '\n' && (cur + 1) == ctx.get_string_end()) { // Special case for new line at end. return true; } else { @@ -463,9 +561,9 @@ line_end_token_matcher: (cur, inout ctx) -> bool = +line_start_token_matcher: (cur, inout ctx) -> bool = { - return cur == ctx.begin || // Start of string + return cur == ctx.get_string_start() || // Start of string (match_new_line && (cur - 1)* == '\n'); // Start of new line } @@ -474,9 +572,23 @@ line_start_token_matcher: (cur, inout ctx) -> bool // // Parsed in group_token. // -lookahead_token_matcher: (cur, inout ctx, func) -> bool = +lookahead_token_matcher: (cur, inout ctx, func) -> bool = +{ + r := func(make_forward_iterator(cur), make_forward_match_context(ctx), true_end_func()); + if !positive { + r.matched = !r.matched; + } + + return r.matched; +} + +// Regex syntax: (?<=) or (? (cur, inout ctx, func) -> bool = { - r := func(cur, ctx, true_end_func()); + r := func(make_reverse_iterator(cur), make_reverse_match_context(ctx), true_end_func()); if !positive { r.matched = !r.matched; } @@ -498,10 +610,10 @@ range_flags: type = { // Regex syntax: {min, max} Example: a{2,4} // -range_token_matcher: type = +range_token_matcher: type = { - match: (cur: Iter, inout ctx, inner, reset_func, end_func, tail) -> _ = + match: (cur: Iter, inout ctx, inner, reset_func, end_func, tail) -> _ = { if range_flags::possessive == kind { return match_possessive(cur, ctx, inner, end_func, tail); @@ -641,15 +753,15 @@ word_boundary_token_matcher: (inout cur, inout ctx) -> boo { words : word_class = (); is_match := false; - if cur == ctx.begin { // String start + if cur == ctx.begin { // Iteration start if cur != ctx.end { // No empty string is_match = words..includes(cur*); } } - else if cur == ctx.end { // String end + else if cur == ctx.end { // Iteration end is_match = words..includes((cur - 1)*); } - else { // Middle of string + else { // Middle of iteration is_match = (words..includes((cur - 1)*) && !words..includes(cur*)) // End of word: \w\W || (!words..includes((cur - 1)*) && words..includes(cur*)); // Start of word: \W\w @@ -670,10 +782,9 @@ word_boundary_token_matcher: (inout cur, inout ctx) -> boo // // Regular expression implementation -regular_expression: type = +regular_expression: type = { - matcher: type == matcher_wrapper_type; // TODO: Remove when nested types are allowed: https://github.com/hsutter/cppfront/issues/727 - context: type == matcher_context_type>; // TODO: Remove when nested types are allowed: https://github.com/hsutter/cppfront/issues/727 + context: type == matcher_context_type; // TODO: Remove when nested types are allowed: https://github.com/hsutter/cppfront/issues/727 search_return: type = { @@ -687,6 +798,12 @@ regular_expression: type = pos = unchecked_narrow(std::distance(ctx_.begin, pos_)); } + operator=:(out this, begin: Iter, end: Iter) = { + matched = false; + ctx = (begin, end); + pos = 0; + } + group_number: (this) = ctx..size(); group: (this, g: int) = ctx..get_group_string(g); group_start: (this, g: int) = ctx..get_group_start(g); @@ -696,8 +813,13 @@ regular_expression: type = group_start: (this, g: bstring) = group_start(get_group_id(g)); group_end: (this, g: bstring) = group_end(get_group_id(g)); + update: (inout this, r: match_return) = { + matched = r.matched; + pos = unchecked_narrow(std::distance(ctx.begin, r.pos)); + } + private get_group_id: (this, g: bstring) -> _ = { - group_id := matcher::get_named_group_index(g); + group_id := matcher::get_named_group_index(g); if -1 == group_id { // TODO: Throw error. } @@ -705,6 +827,37 @@ regular_expression: type = } } + find_all: (in this, forward func, str: bview) = find_all(func, str..begin(), str..end()); + find_all: (in this, forward func, str: bview, start: int) = find_all(func, get_iter(str, start), str..end()); + find_all: (in this, forward func, str: bview, start: int, length : int) = find_all(func, get_iter(str, start), get_iter(str, start + length)); + find_all: (in this, func, start: Iter, end: Iter) = + { + sr := search_return(start, end); + cont := true; + cur := start; + + while cont { + r := search_with_context(sr.ctx, cur); + cont = r.matched; // First update the continue so that the user can override it. + + if r.matched { + sr..update(r); + cont = func(sr); + } + + if cont { + // Prevent infinity loop for zero length match. + cont = 0 != sr.ctx..get_group_end(0) - sr.ctx..get_group_start(0); + } + + // Check now if to continue, user may override + if cont { + cur = start + sr.ctx..get_group_end(0); + sr.ctx.reset(); + } + } + } + match: (in this, str: bview) = match(str..begin(), str..end()); match: (in this, str: bview, start) = match(get_iter(str, start), str..end()); match: (in this, str: bview, start, length) = match(get_iter(str, start), get_iter(str, start + length)); @@ -712,21 +865,27 @@ regular_expression: type = { ctx: context = (start, end); - r := matcher::entry(start, ctx); + r := matcher::entry(start, ctx); return search_return(r.matched && r.pos == end, ctx, r.pos); } search: (in this, str: bview) = search(str..begin(), str..end()); search: (in this, str: bview, start) = search(get_iter(str, start), str..end()); search: (in this, str: bview, start, length) = search(get_iter(str, start), get_iter(str, start + length)); - search: (in this, start: Iter, end: Iter) -> search_return = + search: (in this, start: Iter, end: Iter) -> search_return = { ctx: context = (start, end); + r := search_with_context(ctx, start); + return search_return(r.matched, ctx, r.pos); + } + + private search_with_context: (in this, inout ctx: context, start: Iter) -> match_return = + { r := ctx..fail(); cur:= start; while true next (cur++) { - r = matcher::entry(cur, ctx); + r = matcher::entry(cur, ctx); if r.matched { break; } @@ -734,12 +893,18 @@ regular_expression: type = if cur == ctx.end { break; } + + if matcher::is_start_match() { + break; // Always break with \G option. + } } - return search_return(r.matched, ctx, r.pos); + return r; } - to_string: (in this) = matcher_wrapper::to_string(); + + + to_string: (in this) = matcher::to_string(); // Helper functions // diff --git a/regression-tests/pure2-regex-general.cpp2 b/regression-tests/pure2-regex-general.cpp2 new file mode 100644 index 0000000000..4eaa95f7a1 --- /dev/null +++ b/regression-tests/pure2-regex-general.cpp2 @@ -0,0 +1,32 @@ +general_regex_test: @regex type = { + regex_01 := R"(AA)"; + regex_02 := R"((?=aa))"; + run: (this) = { + std::cout << "Running tests_01_char_matcher:"<< std::endl; + + std::cout << "Not full match fails: " << regex_01.match("AAaa").matched << std::endl; + std::cout << "Full match is ok: " << regex_01.match("AA").matched << std::endl; + std::cout << "Search finds at position 1: " << regex_01.search("aAAaa").group_start(0) << std::endl; + std::cout << "Search finds at position 3: " << regex_01.search("aaaAAaa").group_start(0) << std::endl; + + count := 0; + func := :(r) -> bool == { + count&$* += 1; + std::cout << "Find all finds at position: " << r.group_start(0) << std::endl; + return true; + }; + + str : std::string = "aAAaAAaAAa"; + regex_01..find_all(func, str); + std::cout << "Find all found 3 matched: " << count << std::endl; + + count = 0; + str = "bbaabb"; + regex_02..find_all(func, str); + std::cout << "Find all found 1 match: " << count << std::endl; + } +} + +main: () = { + general_regex_test().run(); +} diff --git a/regression-tests/pure2-regex_01_char_matcher.cpp2 b/regression-tests/pure2-regex_01_char_matcher.cpp2 index 1c3a376642..0483361472 100644 --- a/regression-tests/pure2-regex_01_char_matcher.cpp2 +++ b/regression-tests/pure2-regex_01_char_matcher.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; diff --git a/regression-tests/pure2-regex_02_ranges.cpp2 b/regression-tests/pure2-regex_02_ranges.cpp2 index 8f71810b03..7124c08ba5 100644 --- a/regression-tests/pure2-regex_02_ranges.cpp2 +++ b/regression-tests/pure2-regex_02_ranges.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; diff --git a/regression-tests/pure2-regex_03_wildcard.cpp2 b/regression-tests/pure2-regex_03_wildcard.cpp2 index 62688e4695..a48ed941af 100644 --- a/regression-tests/pure2-regex_03_wildcard.cpp2 +++ b/regression-tests/pure2-regex_03_wildcard.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; diff --git a/regression-tests/pure2-regex_04_start_end.cpp2 b/regression-tests/pure2-regex_04_start_end.cpp2 index 87a4c8fb9c..63754c23fa 100644 --- a/regression-tests/pure2-regex_04_start_end.cpp2 +++ b/regression-tests/pure2-regex_04_start_end.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; @@ -172,6 +173,7 @@ test_tests_04_start_end: @regex type = { regex_07 := R"(^)"; regex_08 := R"($)"; regex_09 := R"($b)"; + regex_10 := R"(\GX.*X)"; run: (this) = { std::cout << "Running tests_04_start_end:"<< std::endl; test(regex_01, "01", R"(^abc$)", "abc", "y", R"($&)", "abc"); @@ -183,6 +185,7 @@ test_tests_04_start_end: @regex type = { test(regex_07, "07", R"(^)", "abc", "y", R"($&)", ""); test(regex_08, "08", R"($)", "abc", "y", R"($&)", ""); test(regex_09, "09", R"($b)", "b", "n", R"(-)", "-"); + test(regex_10, "10", R"(\GX.*X)", "aaaXbX", "n", R"(-)", "-"); std::cout << std::endl; } } diff --git a/regression-tests/pure2-regex_05_classes.cpp2 b/regression-tests/pure2-regex_05_classes.cpp2 index 4e9926da54..4e6ebb8387 100644 --- a/regression-tests/pure2-regex_05_classes.cpp2 +++ b/regression-tests/pure2-regex_05_classes.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; diff --git a/regression-tests/pure2-regex_06_boundaries.cpp2 b/regression-tests/pure2-regex_06_boundaries.cpp2 index 5b96fca36d..75110c40e6 100644 --- a/regression-tests/pure2-regex_06_boundaries.cpp2 +++ b/regression-tests/pure2-regex_06_boundaries.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; diff --git a/regression-tests/pure2-regex_07_short_classes.cpp2 b/regression-tests/pure2-regex_07_short_classes.cpp2 index 3723d7f773..5bd9774d98 100644 --- a/regression-tests/pure2-regex_07_short_classes.cpp2 +++ b/regression-tests/pure2-regex_07_short_classes.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; diff --git a/regression-tests/pure2-regex_08_alternatives.cpp2 b/regression-tests/pure2-regex_08_alternatives.cpp2 index 892d8715ef..23e413a57b 100644 --- a/regression-tests/pure2-regex_08_alternatives.cpp2 +++ b/regression-tests/pure2-regex_08_alternatives.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; diff --git a/regression-tests/pure2-regex_09_groups.cpp2 b/regression-tests/pure2-regex_09_groups.cpp2 index c3949e3a2e..2c7836ff6f 100644 --- a/regression-tests/pure2-regex_09_groups.cpp2 +++ b/regression-tests/pure2-regex_09_groups.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; diff --git a/regression-tests/pure2-regex_10_escapes.cpp2 b/regression-tests/pure2-regex_10_escapes.cpp2 index 72b3ff77a5..be0cb3557d 100644 --- a/regression-tests/pure2-regex_10_escapes.cpp2 +++ b/regression-tests/pure2-regex_10_escapes.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; diff --git a/regression-tests/pure2-regex_11_group_references.cpp2 b/regression-tests/pure2-regex_11_group_references.cpp2 index 1301bf15c2..46cf13323e 100644 --- a/regression-tests/pure2-regex_11_group_references.cpp2 +++ b/regression-tests/pure2-regex_11_group_references.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; diff --git a/regression-tests/pure2-regex_12_case_insensitive.cpp2 b/regression-tests/pure2-regex_12_case_insensitive.cpp2 index bfec41f3b1..dc14f2bfbe 100644 --- a/regression-tests/pure2-regex_12_case_insensitive.cpp2 +++ b/regression-tests/pure2-regex_12_case_insensitive.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; diff --git a/regression-tests/pure2-regex_13_possessive_modifier.cpp2 b/regression-tests/pure2-regex_13_possessive_modifier.cpp2 index 0f014327c1..ad683ef050 100644 --- a/regression-tests/pure2-regex_13_possessive_modifier.cpp2 +++ b/regression-tests/pure2-regex_13_possessive_modifier.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; diff --git a/regression-tests/pure2-regex_14_multiline_modifier.cpp2 b/regression-tests/pure2-regex_14_multiline_modifier.cpp2 index c6d205ca1a..24a9ec610e 100644 --- a/regression-tests/pure2-regex_14_multiline_modifier.cpp2 +++ b/regression-tests/pure2-regex_14_multiline_modifier.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; diff --git a/regression-tests/pure2-regex_15_group_modifiers.cpp2 b/regression-tests/pure2-regex_15_group_modifiers.cpp2 index 1d2aa9090d..4816874c75 100644 --- a/regression-tests/pure2-regex_15_group_modifiers.cpp2 +++ b/regression-tests/pure2-regex_15_group_modifiers.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; diff --git a/regression-tests/pure2-regex_16_perl_syntax_modifier.cpp2 b/regression-tests/pure2-regex_16_perl_syntax_modifier.cpp2 index c158317045..35e14e2c73 100644 --- a/regression-tests/pure2-regex_16_perl_syntax_modifier.cpp2 +++ b/regression-tests/pure2-regex_16_perl_syntax_modifier.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; diff --git a/regression-tests/pure2-regex_17_comments.cpp2 b/regression-tests/pure2-regex_17_comments.cpp2 index 5d42ce3d51..9a31848bf0 100644 --- a/regression-tests/pure2-regex_17_comments.cpp2 +++ b/regression-tests/pure2-regex_17_comments.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; diff --git a/regression-tests/pure2-regex_18_branch_reset.cpp2 b/regression-tests/pure2-regex_18_branch_reset.cpp2 index 6f3dcdf01e..3260bacae1 100644 --- a/regression-tests/pure2-regex_18_branch_reset.cpp2 +++ b/regression-tests/pure2-regex_18_branch_reset.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; diff --git a/regression-tests/pure2-regex_19_lookahead.cpp2 b/regression-tests/pure2-regex_19_lookahead.cpp2 index c5b399f377..bfa9786bbe 100644 --- a/regression-tests/pure2-regex_19_lookahead.cpp2 +++ b/regression-tests/pure2-regex_19_lookahead.cpp2 @@ -94,6 +94,7 @@ create_result: (resultExpr: std::string, r) -> std::string = { } result += std::to_string(pos); } + next++; } else { std::cerr << "Not implemented"; @@ -191,6 +192,14 @@ test_tests_19_lookahead: @regex type = { regex_26 := R"(^(a*?)(?!(aa|aaaa)*$)(?=a\z))"; regex_27 := R"(a(?!b(?!c))(..))"; regex_28 := R"(a(?!b(?=a))(..))"; + regex_29 := R"((?=foo))"; + regex_30 := R"((?=foo))"; + regex_31 := R"(.*(?=foo))"; + regex_32 := R"((?=.*P)P)"; + regex_33 := R"(X(?=foo)f)"; + regex_34 := R"(X(?=foo))"; + regex_35 := R"((?=XY*foo))"; + regex_36 := R"(^(?=XY*foo))"; regex_37 := R"(X(\w+)(?=\s)|X(\w+))"; regex_38 := R"(^a*(?=b)b)"; regex_39 := R"('(?!\A)x'm)"; @@ -208,6 +217,8 @@ test_tests_19_lookahead: @regex type = { regex_51 := R"(((?s)b.)c(?!\N))"; regex_52 := R"('(b.)c(?!\N)'s)"; regex_53 := R"(a*(?!))"; + regex_54 := R"((?)foo)"; + regex_55 := R"((?ABC)foo)"; run: (this) = { std::cout << "Running tests_19_lookahead:"<< std::endl; test(regex_01, "01", R"(a(?!b).)", "abad", "y", R"($&)", "ad"); @@ -238,6 +249,14 @@ test_tests_19_lookahead: @regex type = { test(regex_26, "26", R"(^(a*?)(?!(aa|aaaa)*$)(?=a\z))", "aaaaaaaa", "y", R"($1)", "aaaaaaa"); test(regex_27, "27", R"(a(?!b(?!c))(..))", "abababc", "y", R"($1)", "bc"); test(regex_28, "28", R"(a(?!b(?=a))(..))", "abababc", "y", R"($1)", "bc"); + test(regex_29, "29", R"((?=foo))", "foo", "y", R"(@+)", "0"); + test(regex_30, "30", R"((?=foo))", "XfooY", "y", R"(@+)", "1"); + test(regex_31, "31", R"(.*(?=foo))", "XfooY", "y", R"(@+)", "1"); + test(regex_32, "32", R"((?=.*P)P)", "aP", "y", R"(@+)", "2"); + test(regex_33, "33", R"(X(?=foo)f)", "..XfooY..", "y", R"(@+)", "4"); + test(regex_34, "34", R"(X(?=foo))", "..XfooY..", "y", R"(@+)", "3"); + test(regex_35, "35", R"((?=XY*foo))", "Xfoo", "y", R"(@+)", "0"); + test(regex_36, "36", R"(^(?=XY*foo))", "Xfoo", "y", R"(@+)", "0"); test(regex_37, "37", R"(X(\w+)(?=\s)|X(\w+))", "Xab", "y", R"([$1-$2])", "[-ab]"); test(regex_38, "38", R"(^a*(?=b)b)", "ab", "y", R"($&)", "ab"); test(regex_39, "39", R"('(?!\A)x'm)", "a\nxb\n", "y", R"(-)", "-"); @@ -255,6 +274,8 @@ test_tests_19_lookahead: @regex type = { test(regex_51, "51", R"(((?s)b.)c(?!\N))", "a\nb\nc\n", "y", R"($1:$&)", "b\n:b\nc"); test(regex_52, "52", R"('(b.)c(?!\N)'s)", "a\nb\nc\n", "y", R"($1:$&)", "b\n:b\nc"); test(regex_53, "53", R"(a*(?!))", "aaaab", "n", R"(-)", "-"); + test(regex_54, "54", R"((?)foo)", "bar>ABCfoo", "y", R"($&)", "foo"); + test(regex_55, "55", R"((?ABC)foo)", "bar>ABCfoo", "y", R"($&)", "ABCfoo"); std::cout << std::endl; } } diff --git a/regression-tests/pure2-regex_20_lookbehind.cpp b/regression-tests/pure2-regex_20_lookbehind.cpp new file mode 100644 index 0000000000..1f549a3467 --- /dev/null +++ b/regression-tests/pure2-regex_20_lookbehind.cpp @@ -0,0 +1,8989 @@ + +#include "cpp2regex.h" + +//=== Cpp2 type declarations ==================================================== + + +#include "cpp2util.h" + +#line 1 "build/20_lookbehind.cpp2" + +#line 166 "build/20_lookbehind.cpp2" +class test_tests_20_lookbehind; + + +//=== Cpp2 type definitions and function declarations =========================== + +#line 1 "build/20_lookbehind.cpp2" +[[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; + +#line 113 "build/20_lookbehind.cpp2" +[[nodiscard]] auto sanitize(std::string str) -> std::string; + +#line 125 "build/20_lookbehind.cpp2" +template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, + cpp2::impl::in resultExpected) -> void; + +#line 166 "build/20_lookbehind.cpp2" +class test_tests_20_lookbehind { + +#line 223 "build/20_lookbehind.cpp2" + public: auto run() const& -> void; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_01_matcher() = default; + public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_01_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_02_matcher() = default; + public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_02_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_03_matcher() = default; + public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_03_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_04_matcher() = default; + public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_04_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_05_matcher() = default; + public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_05_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_06_matcher() = default; + public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_06_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_06 {}; public: template class regex_07_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_07_matcher() = default; + public: regex_07_matcher(regex_07_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_07_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_07 {}; public: template class regex_08_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_08_matcher() = default; + public: regex_08_matcher(regex_08_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_08_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_08 {}; public: template class regex_09_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_09_matcher() = default; + public: regex_09_matcher(regex_09_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_09_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_09 {}; public: template class regex_10_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_10_matcher() = default; + public: regex_10_matcher(regex_10_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_10_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_10 {}; public: template class regex_11_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_11_matcher() = default; + public: regex_11_matcher(regex_11_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_11_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_11 {}; public: template class regex_12_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_12_matcher() = default; + public: regex_12_matcher(regex_12_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_12_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_12 {}; public: template class regex_13_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_13_matcher() = default; + public: regex_13_matcher(regex_13_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_13_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_13 {}; public: template class regex_14_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_14_matcher() = default; + public: regex_14_matcher(regex_14_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_14_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_14 {}; public: template class regex_15_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_15_matcher() = default; + public: regex_15_matcher(regex_15_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_15_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_15 {}; public: template class regex_16_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_16_matcher() = default; + public: regex_16_matcher(regex_16_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_16_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_16 {}; public: template class regex_17_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_17_matcher() = default; + public: regex_17_matcher(regex_17_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_17_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_17 {}; public: template class regex_18_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_18_matcher() = default; + public: regex_18_matcher(regex_18_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_18_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_18 {}; public: template class regex_19_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_19_matcher() = default; + public: regex_19_matcher(regex_19_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_19_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_19 {}; public: template class regex_20_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_4 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_20_matcher() = default; + public: regex_20_matcher(regex_20_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_20_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_20 {}; public: template class regex_21_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_4 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_21_matcher() = default; + public: regex_21_matcher(regex_21_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_21_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_21 {}; public: template class regex_22_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_22_matcher() = default; + public: regex_22_matcher(regex_22_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_22_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_22 {}; public: template class regex_23_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_23_matcher() = default; + public: regex_23_matcher(regex_23_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_23_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_23 {}; public: template class regex_24_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_24_matcher() = default; + public: regex_24_matcher(regex_24_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_24_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_24 {}; public: template class regex_25_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_25_matcher() = default; + public: regex_25_matcher(regex_25_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_25_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_25 {}; public: template class regex_26_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_26_matcher() = default; + public: regex_26_matcher(regex_26_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_26_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_26 {}; public: template class regex_27_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_4 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_5 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_6 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_27_matcher() = default; + public: regex_27_matcher(regex_27_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_27_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_27 {}; public: template class regex_28_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_4 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_5 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_6 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_28_matcher() = default; + public: regex_28_matcher(regex_28_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_28_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_28 {}; public: template class regex_29_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_4 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_5 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_6 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_29_matcher() = default; + public: regex_29_matcher(regex_29_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_29_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_29 {}; public: template class regex_30_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_4 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_5 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_6 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_30_matcher() = default; + public: regex_30_matcher(regex_30_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_30_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_30 {}; public: template class regex_31_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_31_matcher() = default; + public: regex_31_matcher(regex_31_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_31_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_31 {}; public: template class regex_32_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_32_matcher() = default; + public: regex_32_matcher(regex_32_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_32_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_32 {}; public: template class regex_33_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_33_matcher() = default; + public: regex_33_matcher(regex_33_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_33_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_33 {}; public: template class regex_34_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_34_matcher() = default; + public: regex_34_matcher(regex_34_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_34_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_34 {}; public: template class regex_35_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_35_matcher() = default; + public: regex_35_matcher(regex_35_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_35_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_35 {}; public: template class regex_36_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_4 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_5 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_6 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_36_matcher() = default; + public: regex_36_matcher(regex_36_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_36_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_36 {}; public: template class regex_37_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_4 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_5 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_6 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_37_matcher() = default; + public: regex_37_matcher(regex_37_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_37_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_37 {}; public: template class regex_38_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_4 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_5 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_6 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_38_matcher() = default; + public: regex_38_matcher(regex_38_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_38_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_38 {}; public: template class regex_39_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_4 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_5 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_6 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_39_matcher() = default; + public: regex_39_matcher(regex_39_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_39_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_39 {}; public: template class regex_40_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_40_matcher() = default; + public: regex_40_matcher(regex_40_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_40_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_40 {}; public: template class regex_41_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_41_matcher() = default; + public: regex_41_matcher(regex_41_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_41_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_41 {}; public: template class regex_42_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_42_matcher() = default; + public: regex_42_matcher(regex_42_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_42_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_42 {}; public: template class regex_43_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_43_matcher() = default; + public: regex_43_matcher(regex_43_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_43_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_43 {}; public: template class regex_44_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_44_matcher() = default; + public: regex_44_matcher(regex_44_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_44_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_44 {}; public: template class regex_45_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_45_matcher() = default; + public: regex_45_matcher(regex_45_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_45_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_45 {}; public: template class regex_46_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_46_matcher() = default; + public: regex_46_matcher(regex_46_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_46_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_46 {}; public: template class regex_47_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_47_matcher() = default; + public: regex_47_matcher(regex_47_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_47_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_47 {}; public: template class regex_48_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_48_matcher() = default; + public: regex_48_matcher(regex_48_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_48_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_48 {}; public: template class regex_49_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_49_matcher() = default; + public: regex_49_matcher(regex_49_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_49_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_49 {}; public: template class regex_50_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_50_matcher() = default; + public: regex_50_matcher(regex_50_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_50_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_50 {}; public: template class regex_51_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_51_matcher() = default; + public: regex_51_matcher(regex_51_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_51_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_51 {}; public: template class regex_52_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_52_matcher() = default; + public: regex_52_matcher(regex_52_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_52_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_52 {}; public: template class regex_53_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_53_matcher() = default; + public: regex_53_matcher(regex_53_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_53_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_53 {}; public: template class regex_54_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_54_matcher() = default; + public: regex_54_matcher(regex_54_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_54_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_54 {}; public: template class regex_55_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_4 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_55_matcher() = default; + public: regex_55_matcher(regex_55_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_55_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_55 {}; public: template class regex_56_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_56_matcher() = default; + public: regex_56_matcher(regex_56_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_56_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_56 {}; + public: test_tests_20_lookbehind() = default; + public: test_tests_20_lookbehind(test_tests_20_lookbehind const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(test_tests_20_lookbehind const&) -> void = delete; + + +#line 283 "build/20_lookbehind.cpp2" +}; +auto main() -> int; + +//=== Cpp2 function definitions ================================================= + +#line 1 "build/20_lookbehind.cpp2" +[[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string{ +#line 2 "build/20_lookbehind.cpp2" + std::string result {""}; + + auto get_next {[_0 = (&resultExpr)](auto const& iter) mutable -> auto{ + auto start {std::distance(CPP2_UFCS(cbegin)((*cpp2::impl::assert_not_null(_0))), iter)}; + auto firstDollar {CPP2_UFCS(find)((*cpp2::impl::assert_not_null(_0)), "$", start)}; + auto firstAt {CPP2_UFCS(find)((*cpp2::impl::assert_not_null(_0)), "@", cpp2::move(start))}; + + auto end {std::min(cpp2::move(firstDollar), cpp2::move(firstAt))}; + if (end != std::string::npos) { + return CPP2_UFCS(cbegin)((*cpp2::impl::assert_not_null(_0))) + cpp2::move(end); + } + else { + return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); + } + }}; + auto extract_group_and_advance {[](auto& iter) -> auto{ + auto start {iter}; + + for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {} + + return std::stoi(std::string(cpp2::move(start), iter)); + }}; + auto extract_until {[](auto& iter, cpp2::impl::in to) -> auto{ + auto start {iter}; + + for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication) + + return std::string(cpp2::move(start), iter); + }}; + + auto iter {CPP2_UFCS(begin)(resultExpr)}; + + while( iter != CPP2_UFCS(end)(resultExpr) ) { + auto next {get_next(iter)}; + + if (next != iter) { + result += std::string(iter, next); + } + if (next != CPP2_UFCS(end)(resultExpr)) { + if (*cpp2::impl::assert_not_null(next) == '$') { + ++next; + + if (*cpp2::impl::assert_not_null(next) == '&') { + ++next; + result += CPP2_UFCS(group)(r, 0); + } + else {if (*cpp2::impl::assert_not_null(next) == '-' || *cpp2::impl::assert_not_null(next) == '+') { + auto is_start {*cpp2::impl::assert_not_null(next) == '-'}; + ++next; + if (*cpp2::impl::assert_not_null(next) == '{') { + ++next; // Skip { + auto group {extract_until(next, '}')}; + ++next; // Skip } + result += CPP2_UFCS(group)(r, cpp2::move(group)); + } + else {if (*cpp2::impl::assert_not_null(next) == '[') { + ++next; // Skip [ + auto group {extract_group_and_advance(next)}; + ++next; // Skip ] + + if (cpp2::move(is_start)) { + result += std::to_string(CPP2_UFCS(group_start)(r, cpp2::move(group))); + } + else { + result += std::to_string(CPP2_UFCS(group_end)(r, cpp2::move(group))); + } + } + else { + // Return max group + result += CPP2_UFCS(group)(r, CPP2_UFCS(group_number)(r) - 1); + }} + } + else {if (std::isdigit(*cpp2::impl::assert_not_null(next))) { + auto group {extract_group_and_advance(next)}; + result += CPP2_UFCS(group)(r, cpp2::move(group)); + } + else { + std::cerr << "Not implemented"; + }}} + } + else {if (*cpp2::impl::assert_not_null(next) == '@') { + ++next; + + if (*cpp2::impl::assert_not_null(next) == '-' || *cpp2::impl::assert_not_null(next) == '+') { + auto i {0}; + for( ; cpp2::impl::cmp_less(i,cpp2::unchecked_narrow(CPP2_UFCS(group_number)(r))); ++i ) { + auto pos {0}; + if (*cpp2::impl::assert_not_null(next) == '-') { + pos = CPP2_UFCS(group_start)(r, i); + } + else { + pos = CPP2_UFCS(group_end)(r, i); + } + result += std::to_string(cpp2::move(pos)); + } + ++next; + } + else { + std::cerr << "Not implemented"; + } + } + else { + std::cerr << "Not implemented."; + }} + } + iter = cpp2::move(next); + } + + return result; +} + +#line 113 "build/20_lookbehind.cpp2" +[[nodiscard]] auto sanitize(std::string str) -> std::string +{ + str = cpp2::string_util::replace_all(str, "\a", "\\a"); + str = cpp2::string_util::replace_all(str, "\f", "\\f"); + str = cpp2::string_util::replace_all(str, "\x1b", "\\e"); + str = cpp2::string_util::replace_all(str, "\n", "\\n"); + str = cpp2::string_util::replace_all(str, "\r", "\\r"); + str = cpp2::string_util::replace_all(str, "\t", "\\t"); + + return cpp2::move(str); +} + +#line 125 "build/20_lookbehind.cpp2" +template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, + cpp2::impl::in resultExpected) -> void{ + + std::string warning {""}; + if (CPP2_UFCS(to_string)(regex) != regex_str) { + warning = "Warning: Parsed regex does not match."; + } + + std::string status {"OK"}; + + auto r {CPP2_UFCS(search)(regex, str)}; + + if ("y" == kind || "yM" == kind || "yS" == kind || "yB" == kind) { + if (!(r.matched)) { + status = "Failure: Regex should apply."; + } + else { + // Have a match check the result + + auto result {create_result(resultExpr, cpp2::move(r))}; + + if (result != resultExpected) { + status = "Failure: Result is wrong. (is: " + cpp2::to_string(sanitize(cpp2::move(result))) + ")"; + } + } + } + else {if ("n" == kind) { + if (r.matched) { + status = "Failure: Regex should not apply. Result is '" + cpp2::to_string(CPP2_UFCS(group)(cpp2::move(r), 0)) + "'"; + } + }else { + status = "Unknown kind '" + cpp2::to_string(kind) + "'"; + }} + + if (!(CPP2_UFCS(empty)(warning))) { + warning += " "; + } + std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; +} + +#line 223 "build/20_lookbehind.cpp2" + auto test_tests_20_lookbehind::run() const& -> void{ + std::cout << "Running tests_20_lookbehind:" << std::endl; + test(regex_01, "01", R"((?<=a)b)", "ab", "y", R"($&)", "b"); + test(regex_02, "02", R"((?<=af?)b)", "ab", "y", R"($&)", "b"); + test(regex_03, "03", R"((?<=a)b)", "cb", "n", R"(-)", "-"); + test(regex_04, "04", R"((?<=a(?:fo)?)b)", "cb", "n", R"(-)", "-"); + test(regex_05, "05", R"((?<=a)b)", "b", "n", R"(-)", "-"); + test(regex_06, "06", R"((?<=a(?:foo)?)b)", "b", "n", R"(-)", "-"); + test(regex_07, "07", R"((?)foo)", "bar>foo", "y", R"($&)", "foo"); + test(regex_50, "50", R"((?)foo)", "bar>foo", "n", R"(-)", "-"); + test(regex_51, "51", R"((?<=bar>ABC)foo)", "bar>ABCfoo", "y", R"($&)", "foo"); + test(regex_52, "52", R"((?ABC)foo)", "bar>ABCfoo", "n", R"(-)", "-"); + test(regex_53, "53", R"((?<=abcd(?<=(aaaabcd))))", "..aaaabcd..", "y", R"($1)", "aaaabcd"); + test(regex_54, "54", R"((?=xy(?<=(aaxy))))", "..aaxy..", "y", R"($1)", "aaxy"); + test(regex_55, "55", R"((?=xy(?<=(aaxyz?))))", "..aaxy..", "y", R"($1)", "aaxy"); + test(regex_56, "56", R"((?<=(?=(aaxy))aa))", "..aaxy..", "y", R"($1)", "aaxy"); + std::cout << std::endl; + } + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_01_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"a"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_01_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_01_matcher::to_string() -> std::string{return R"((?<=a)b)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_02_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"f"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_02_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_2(), cpp2::regex::no_reset(), other, func_3()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_02_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"a"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_2 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_02_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_02_matcher::to_string() -> std::string{return R"((?<=af?)b)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_03_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"a"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_03_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_03_matcher::to_string() -> std::string{return R"((?<=a)b)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_04_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"of"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),2)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,2); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 2;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_04_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_2(), cpp2::regex::no_reset(), other, func_3()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_04_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"a"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_2 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_04_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_04_matcher::to_string() -> std::string{return R"((?<=a(?:fo)?)b)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_05_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"a"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_05_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_05_matcher::to_string() -> std::string{return R"((?<=a)b)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_06_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"oof"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_06_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_2(), cpp2::regex::no_reset(), other, func_3()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_06_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"a"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_2 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_06_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_06_matcher::to_string() -> std::string{return R"((?<=a(?:foo)?)b)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_07_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_07_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_07_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_07_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_07_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_07_matcher::to_string() -> std::string{return R"((? template [[nodiscard]] auto test_tests_20_lookbehind::regex_08_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"boof"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),4)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,4); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 4;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_08_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_2(), cpp2::regex::no_reset(), other, func_3()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_08_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_08_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_2 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_08_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_08_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_08_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_08_matcher::to_string() -> std::string{return R"((? template [[nodiscard]] auto test_tests_20_lookbehind::regex_09_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_09_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_09_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_09_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_09_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_09_matcher::to_string() -> std::string{return R"((? template [[nodiscard]] auto test_tests_20_lookbehind::regex_10_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"aboof"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),5)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,5); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 5;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_10_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_2(), cpp2::regex::no_reset(), other, func_3()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_10_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_10_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_2 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_10_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_10_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_10_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_10_matcher::to_string() -> std::string{return R"((? template [[nodiscard]] auto test_tests_20_lookbehind::regex_11_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_11_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_11_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_11_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_11_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_11_matcher::to_string() -> std::string{return R"((? template [[nodiscard]] auto test_tests_20_lookbehind::regex_12_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"raboof"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),6)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,6); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 6;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_12_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_2(), cpp2::regex::no_reset(), other, func_3()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_12_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_12_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_2 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_12_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_12_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_12_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_12_matcher::to_string() -> std::string{return R"((? template [[nodiscard]] auto test_tests_20_lookbehind::regex_13_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_13_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_13_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_13_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_13_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_13_matcher::to_string() -> std::string{return R"((? template [[nodiscard]] auto test_tests_20_lookbehind::regex_14_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"braboof"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),7)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,7); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 7;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_14_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_2(), cpp2::regex::no_reset(), other, func_3()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_14_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_14_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_2 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_14_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_14_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_14_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_14_matcher::to_string() -> std::string{return R"((? template [[nodiscard]] auto test_tests_20_lookbehind::regex_15_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::class_token_matcher,::cpp2::regex::single_class_entry>::match(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_15_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_0 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_15_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_15_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_15_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_15_matcher::to_string() -> std::string{return R"((? template [[nodiscard]] auto test_tests_20_lookbehind::regex_16_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"e"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_16_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_2(), cpp2::regex::no_reset(), other, func_3()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_16_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::class_token_matcher,::cpp2::regex::single_class_entry>::match(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_16_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_16_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_16_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_16_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_16_matcher::to_string() -> std::string{return R"((? template [[nodiscard]] auto test_tests_20_lookbehind::regex_17_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::class_token_matcher,::cpp2::regex::single_class_entry>::match(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_17_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + if (!(cpp2::regex::class_token_matcher,::cpp2::regex::single_class_entry>::match(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_17_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_17_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_17_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_17_matcher::to_string() -> std::string{return R"((? template [[nodiscard]] auto test_tests_20_lookbehind::regex_18_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::class_token_matcher,::cpp2::regex::single_class_entry>::match(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_18_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_2(), cpp2::regex::no_reset(), other, func_3()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_18_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_18_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + if (!(cpp2::regex::class_token_matcher,::cpp2::regex::single_class_entry>::match(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_18_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_18_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_18_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_18_matcher::to_string() -> std::string{return R"((? template [[nodiscard]] auto test_tests_20_lookbehind::regex_19_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::class_token_matcher,::cpp2::regex::single_class_entry>::match(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_19_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_2(), cpp2::regex::no_reset(), other, func_3()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_19_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_19_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + if (!(cpp2::regex::class_token_matcher,::cpp2::regex::single_class_entry>::match(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_19_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_19_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_19_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_19_matcher::to_string() -> std::string{return R"((? template [[nodiscard]] auto test_tests_20_lookbehind::regex_20_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_20_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"d"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_20_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::alternative_token_matcher::match(r.pos, ctx, other, func_4(), func_2(), cpp2::regex::no_reset(), func_3(), cpp2::regex::no_reset()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_20_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + + auto tmp_2_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_2 {cpp2::regex::make_on_return(cpp2::move(tmp_2_func))}; + static_cast(cpp2::move(tmp_2)); + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_20_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_3 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_3, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_20_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_20_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_20_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_20_matcher::to_string() -> std::string{return R"((? template [[nodiscard]] auto test_tests_20_lookbehind::regex_21_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_21_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"d"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_21_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::alternative_token_matcher::match(r.pos, ctx, other, func_4(), func_2(), cpp2::regex::no_reset(), func_3(), cpp2::regex::no_reset()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_21_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + + auto tmp_2_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_2 {cpp2::regex::make_on_return(cpp2::move(tmp_2_func))}; + static_cast(cpp2::move(tmp_2)); + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_21_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + if (!(cpp2::regex::class_token_matcher,::cpp2::regex::single_class_entry>::match(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_21_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_21_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_21_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_21_matcher::to_string() -> std::string{return R"((? template [[nodiscard]] auto test_tests_20_lookbehind::regex_22_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"dc"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),2)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,2); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 2;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_22_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + if (!(cpp2::regex::class_token_matcher,::cpp2::regex::single_class_entry>::match(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_22_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_22_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_22_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_22_matcher::to_string() -> std::string{return R"((? template [[nodiscard]] auto test_tests_20_lookbehind::regex_23_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + std::array str_tmp_0 {"a"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + ctx.set_group_start(1, r.pos); + + auto tmp_1_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_1 {cpp2::regex::make_on_return(cpp2::move(tmp_1_func))}; + static_cast(cpp2::move(tmp_1)); + if (!(cpp2::regex::line_start_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_23_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::line_end_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_23_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_23_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_23_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_23_matcher::to_string() -> std::string{return R"($(?<=^(a)))"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_24_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_24_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_24_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + + std::array str_tmp_1 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_24_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_24_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_24_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_24_matcher::to_string() -> std::string{return R"((.*)c)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_25_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_25_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_25_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_25_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_25_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_25_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_25_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_25_matcher::to_string() -> std::string{return R"((.*)(?<=b))"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_26_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_26_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_26_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_26_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + + std::array str_tmp_2 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_26_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_26_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_26_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_26_matcher::to_string() -> std::string{return R"((.*)(?<=b)c)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_27_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_27_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_27_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_27_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_2 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_27_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::alternative_token_matcher::match(r.pos, ctx, other, func_6(), func_4(), cpp2::regex::no_reset(), func_5(), cpp2::regex::no_reset()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_27_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_27_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_27_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_27_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_27_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_27_matcher::to_string() -> std::string{return R"((.*)(?<=b|c))"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_28_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_28_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_28_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_28_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_2 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_28_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::alternative_token_matcher::match(r.pos, ctx, other, func_6(), func_4(), cpp2::regex::no_reset(), func_5(), cpp2::regex::no_reset()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_28_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_28_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + + std::array str_tmp_3 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_3, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_28_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_28_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_28_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_28_matcher::to_string() -> std::string{return R"((.*)(?<=b|c)c)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_29_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_29_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_29_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_29_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_2 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_29_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::alternative_token_matcher::match(r.pos, ctx, other, func_6(), func_4(), cpp2::regex::no_reset(), func_5(), cpp2::regex::no_reset()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_29_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_29_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_29_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_29_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_29_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_29_matcher::to_string() -> std::string{return R"((.*)(?<=c|b))"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_30_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_30_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_30_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_30_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_2 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_30_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::alternative_token_matcher::match(r.pos, ctx, other, func_6(), func_4(), cpp2::regex::no_reset(), func_5(), cpp2::regex::no_reset()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_30_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_30_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + + std::array str_tmp_3 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_3, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_30_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_30_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_30_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_30_matcher::to_string() -> std::string{return R"((.*)(?<=c|b)c)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_31_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_31_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_31_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::class_token_matcher,::cpp2::regex::single_class_entry>::match(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_31_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_31_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_31_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_31_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_31_matcher::to_string() -> std::string{return R"((.*)(?<=[bc]))"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_32_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_32_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_32_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::class_token_matcher,::cpp2::regex::single_class_entry>::match(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_32_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + + std::array str_tmp_1 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_32_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_32_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_32_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_32_matcher::to_string() -> std::string{return R"((.*)(?<=[bc])c)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_33_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_33_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_33_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + + std::array str_tmp_1 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_33_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_33_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_33_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_33_matcher::to_string() -> std::string{return R"((.*?)c)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_34_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_34_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_34_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_34_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_34_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_34_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_34_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_34_matcher::to_string() -> std::string{return R"((.*?)(?<=b))"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_35_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_35_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_35_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_35_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + + std::array str_tmp_2 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_35_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_35_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_35_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_35_matcher::to_string() -> std::string{return R"((.*?)(?<=b)c)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_36_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_36_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_36_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_36_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_2 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_36_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::alternative_token_matcher::match(r.pos, ctx, other, func_6(), func_4(), cpp2::regex::no_reset(), func_5(), cpp2::regex::no_reset()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_36_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_36_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_36_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_36_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_36_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_36_matcher::to_string() -> std::string{return R"((.*?)(?<=b|c))"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_37_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_37_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_37_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_37_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_2 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_37_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::alternative_token_matcher::match(r.pos, ctx, other, func_6(), func_4(), cpp2::regex::no_reset(), func_5(), cpp2::regex::no_reset()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_37_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_37_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + + std::array str_tmp_3 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_3, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_37_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_37_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_37_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_37_matcher::to_string() -> std::string{return R"((.*?)(?<=b|c)c)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_38_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_38_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_38_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_38_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_2 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_38_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::alternative_token_matcher::match(r.pos, ctx, other, func_6(), func_4(), cpp2::regex::no_reset(), func_5(), cpp2::regex::no_reset()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_38_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_38_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_38_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_38_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_38_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_38_matcher::to_string() -> std::string{return R"((.*?)(?<=c|b))"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_39_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_39_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_39_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_39_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_2 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_39_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::alternative_token_matcher::match(r.pos, ctx, other, func_6(), func_4(), cpp2::regex::no_reset(), func_5(), cpp2::regex::no_reset()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_39_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_39_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + + std::array str_tmp_3 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_3, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_39_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_39_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_39_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_39_matcher::to_string() -> std::string{return R"((.*?)(?<=c|b)c)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_40_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_40_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_40_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::class_token_matcher,::cpp2::regex::single_class_entry>::match(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_40_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_40_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_40_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_40_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_40_matcher::to_string() -> std::string{return R"((.*?)(?<=[bc]))"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_41_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_41_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_41_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::class_token_matcher,::cpp2::regex::single_class_entry>::match(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_41_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + + std::array str_tmp_1 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_41_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_41_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_41_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_41_matcher::to_string() -> std::string{return R"((.*?)(?<=[bc])c)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_42_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"oof"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_42_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_42_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_42_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_42_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_42_matcher::to_string() -> std::string{return R"((?<=foo))"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_43_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"oof"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_43_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_43_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_43_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_43_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_43_matcher::to_string() -> std::string{return R"((?<=foo))"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_44_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_44_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_44_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"oof"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_44_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_44_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_44_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_44_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_44_matcher::to_string() -> std::string{return R"(.*(?<=foo))"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_45_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_45_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_45_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"oof"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_45_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_45_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_45_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_45_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_45_matcher::to_string() -> std::string{return R"(.*(?<=foo))"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_46_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"oof"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_46_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_1 {"Y"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_46_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_46_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_46_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_46_matcher::to_string() -> std::string{return R"((?<=foo)Y)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_47_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"oof"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_47_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"o"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_2 {"Y"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_47_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_47_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_47_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_47_matcher::to_string() -> std::string{return R"(o(?<=foo)Y)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_48_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + + std::array str_tmp_1 {"oof"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_48_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"X"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + if (!(cpp2::regex::class_token_matcher,::cpp2::regex::single_class_entry>::match(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_48_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_48_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_48_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_48_matcher::to_string() -> std::string{return R"(X(?<=foo.)[YZ])"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_49_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {">rab"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),4)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,4); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 4;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_49_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_1 {"foo"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_49_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_49_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_49_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_49_matcher::to_string() -> std::string{return R"((?<=bar>)foo)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_50_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {">rab"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),4)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,4); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 4;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_50_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_1 {"foo"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_50_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_50_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_50_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_50_matcher::to_string() -> std::string{return R"((?)foo)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_51_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"CBA>rab"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),7)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,7); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 7;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_51_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_1 {"foo"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_51_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_51_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_51_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_51_matcher::to_string() -> std::string{return R"((?<=bar>ABC)foo)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_52_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"CBA>rab"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),7)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,7); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 7;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_52_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_1 {"foo"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_52_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_52_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_52_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_52_matcher::to_string() -> std::string{return R"((?ABC)foo)"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_53_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + std::array str_tmp_0 {"dcbaaaa"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),7)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,7); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 7;} + else {break;} + ctx.set_group_start(1, r.pos); + + auto tmp_1_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_1 {cpp2::regex::make_on_return(cpp2::move(tmp_1_func))}; + static_cast(cpp2::move(tmp_1)); + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_53_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_2()))) {r.matched = false;break;} + + std::array str_tmp_2 {"dcba"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),4)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,4); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 4;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_53_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_53_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_53_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_53_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_53_matcher::to_string() -> std::string{return R"((?<=abcd(?<=(aaaabcd))))"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_54_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + std::array str_tmp_1 {"yxaa"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),4)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,4); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 4;} + else {break;} + ctx.set_group_start(1, r.pos); + + auto tmp_2_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_2 {cpp2::regex::make_on_return(cpp2::move(tmp_2_func))}; + static_cast(cpp2::move(tmp_2)); + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_54_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"xy"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),2)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,2); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 2;} + else {break;} + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_2()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_54_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_54_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_54_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_54_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_54_matcher::to_string() -> std::string{return R"((?=xy(?<=(aaxy))))"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_55_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"z"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_55_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_3(), cpp2::regex::no_reset(), other, func_4()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_55_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_2 {"yxaa"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),4)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,4); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 4;} + else {break;} + ctx.set_group_start(1, r.pos); + + auto tmp_3_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_3 {cpp2::regex::make_on_return(cpp2::move(tmp_3_func))}; + static_cast(cpp2::move(tmp_3)); + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_55_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"xy"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),2)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,2); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 2;} + else {break;} + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_2()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_55_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_55_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_55_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_55_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_55_matcher::to_string() -> std::string{return R"((?=xy(?<=(aaxyz?))))"; } + + + + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_56_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + + std::array str_tmp_1 {"aaxy"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),4)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,4); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 4;} + else {break;} + ctx.set_group_end(1, r.pos); + + auto tmp_2_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_2 {cpp2::regex::make_on_return(cpp2::move(tmp_2_func))}; + static_cast(cpp2::move(tmp_2)); + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_56_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"aa"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),2)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,2); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 2;} + else {break;} + if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_2()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_56_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookbehind_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_20_lookbehind::regex_56_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_20_lookbehind::regex_56_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_20_lookbehind::regex_56_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_20_lookbehind::regex_56_matcher::to_string() -> std::string{return R"((?<=(?=(aaxy))aa))"; } + + +#line 284 "build/20_lookbehind.cpp2" +auto main() -> int{ + CPP2_UFCS(run)(test_tests_20_lookbehind()); +} + diff --git a/regression-tests/pure2-regex_21_atomic_patterns.cpp2 b/regression-tests/pure2-regex_21_atomic_patterns.cpp2 new file mode 100644 index 0000000000..98e98799ac --- /dev/null +++ b/regression-tests/pure2-regex_21_atomic_patterns.cpp2 @@ -0,0 +1,186 @@ +create_result: (resultExpr: std::string, r) -> std::string = { + result: std::string = ""; + + get_next := :(iter) -> _ = { + start := std::distance(resultExpr&$*.cbegin(), iter); + firstDollar := resultExpr&$*.find("$", start); + firstAt := resultExpr&$*.find("@", start); + + end := std::min(firstDollar, firstAt); + if end != std::string::npos { + return resultExpr&$*.cbegin() + end; + } + else { + return resultExpr&$*.cend(); + } + }; + extract_group_and_advance := :(inout iter) -> _ = { + start := iter; + + while std::isdigit(iter*) next iter++ {} + + return std::stoi(std::string(start, iter)); + }; + extract_until := :(inout iter, to: char) -> _ = { + start := iter; + + while (to != iter*) next iter++ {} // TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication) + + return std::string(start, iter); + }; + + iter := resultExpr.begin(); + + while iter != resultExpr.end() { + next := get_next(iter); + + if next != iter { + result += std::string(iter, next); + } + if next != resultExpr.end() { + if next* == '$' { + next++; + + if next* == '&' { + next++; + result += r.group(0); + } + else if next* == '-' || next* == '+' { + is_start := next* == '-'; + next++; + if next* == '{' { + next++; // Skip { + group := extract_until(next, '}'); + next++; // Skip } + result += r.group(group); + } + else if next* == '[' { + next++; // Skip [ + group := extract_group_and_advance(next); + next++; // Skip ] + + if is_start { + result += std::to_string(r.group_start(group)); + } + else { + result += std::to_string(r.group_end(group)); + } + } + else { + // Return max group + result += r.group(r.group_number() - 1); + } + } + else if std::isdigit(next*) { + group := extract_group_and_advance(next); + result += r.group(group); + } + else { + std::cerr << "Not implemented"; + } + } + else if next* == '@' { + next++; + + if next* == '-' || next* == '+' { + i := 0; + while i < cpp2::unchecked_narrow(r.group_number()) next i++ { + pos := 0; + if next* == '-' { + pos = r.group_start(i); + } + else { + pos = r.group_end(i); + } + result += std::to_string(pos); + } + next++; + } + else { + std::cerr << "Not implemented"; + } + } + else { + std::cerr << "Not implemented."; + } + } + iter = next; + } + + return result; +} + +sanitize: (copy str: std::string) -> std::string = +{ + str = cpp2::string_util::replace_all(str, "\a", "\\a"); + str = cpp2::string_util::replace_all(str, "\f", "\\f"); + str = cpp2::string_util::replace_all(str, "\x1b", "\\e"); + str = cpp2::string_util::replace_all(str, "\n", "\\n"); + str = cpp2::string_util::replace_all(str, "\r", "\\r"); + str = cpp2::string_util::replace_all(str, "\t", "\\t"); + + return str; +} + +test: (regex: M, id: std::string, regex_str: std::string, str: std::string, kind: std::string, resultExpr: std::string, + resultExpected: std::string) = { + + warning: std::string = ""; + if regex.to_string() != regex_str { + warning = "Warning: Parsed regex does not match."; + } + + status: std::string = "OK"; + + r := regex.search(str); + + if "y" == kind || "yM" == kind || "yS" == kind || "yB" == kind { + if !r.matched { + status = "Failure: Regex should apply."; + } + else { + // Have a match check the result + + result := create_result(resultExpr, r); + + if result != resultExpected { + status = "Failure: Result is wrong. (is: (sanitize(result))$)"; + } + } + } + else if "n" == kind { + if r.matched { + status = "Failure: Regex should not apply. Result is '(r.group(0))$'"; + } + } else { + status = "Unknown kind '(kind)$'"; + } + + if !warning.empty() { + warning += " "; + } + std::cout << "(id)$_(kind)$: (status)$ (warning)$regex: (regex_str)$ parsed_regex: (regex.to_string())$ str: (sanitize(str))$ result_expr: (resultExpr)$ expected_results (sanitize(resultExpected))$" << std::endl; +} + + +test_tests_21_atomic_patterns: @regex type = { + regex_01 := R"((?>a+)b)"; + regex_02 := R"(((?>a+)b))"; + regex_03 := R"((?>(a+))b)"; + regex_04 := R"(((?>[^()]+)|\([^()]*\))+)"; + regex_05 := R"(round\(((?>[^()]+))\))"; + regex_06 := R"(^((?>(?:aa)?b)?))"; + run: (this) = { + std::cout << "Running tests_21_atomic_patterns:"<< std::endl; + test(regex_01, "01", R"((?>a+)b)", "aaab", "y", R"(-)", "-"); + test(regex_02, "02", R"(((?>a+)b))", "aaab", "y", R"($1)", "aaab"); + test(regex_03, "03", R"((?>(a+))b)", "aaab", "y", R"($1)", "aaa"); + test(regex_04, "04", R"(((?>[^()]+)|\([^()]*\))+)", "((abc(ade)ufh()()x", "y", R"($&)", "abc(ade)ufh()()x"); + test(regex_05, "05", R"(round\(((?>[^()]+))\))", "_I(round(xs * sz),1)", "y", R"($1)", "xs * sz"); + test(regex_06, "06", R"(^((?>(?:aa)?b)?))", "aab", "y", R"($1)", "aab"); + std::cout << std::endl; + } +} +main: () = { + test_tests_21_atomic_patterns().run(); +} diff --git a/regression-tests/test-results/apple-clang-14-c++2b/pure2-regex-general.cpp.execution b/regression-tests/test-results/apple-clang-14-c++2b/pure2-regex-general.cpp.execution new file mode 100644 index 0000000000..c44d084902 --- /dev/null +++ b/regression-tests/test-results/apple-clang-14-c++2b/pure2-regex-general.cpp.execution @@ -0,0 +1,11 @@ +Running tests_01_char_matcher: +Not full match fails: 0 +Full match is ok: 1 +Search finds at position 1: 1 +Search finds at position 3: 3 +Find all finds at position: 1 +Find all finds at position: 4 +Find all finds at position: 7 +Find all found 3 matched: 3 +Find all finds at position: 2 +Find all found 1 match: 1 diff --git a/regression-tests/test-results/apple-clang-14-c++2b/pure2-regex_04_start_end.cpp.execution b/regression-tests/test-results/apple-clang-14-c++2b/pure2-regex_04_start_end.cpp.execution index 6fef36434a..a1e2b9b631 100644 --- a/regression-tests/test-results/apple-clang-14-c++2b/pure2-regex_04_start_end.cpp.execution +++ b/regression-tests/test-results/apple-clang-14-c++2b/pure2-regex_04_start_end.cpp.execution @@ -8,4 +8,5 @@ Running tests_04_start_end: 07_y: OK regex: ^ parsed_regex: ^ str: abc result_expr: $& expected_results 08_y: OK regex: $ parsed_regex: $ str: abc result_expr: $& expected_results 09_n: OK regex: $b parsed_regex: $b str: b result_expr: - expected_results - +10_n: OK regex: \GX.*X parsed_regex: \GX.*X str: aaaXbX result_expr: - expected_results - diff --git a/regression-tests/test-results/apple-clang-14-c++2b/pure2-regex_19_lookahead.cpp.execution b/regression-tests/test-results/apple-clang-14-c++2b/pure2-regex_19_lookahead.cpp.execution index d4c65d951e..0f723eb774 100644 --- a/regression-tests/test-results/apple-clang-14-c++2b/pure2-regex_19_lookahead.cpp.execution +++ b/regression-tests/test-results/apple-clang-14-c++2b/pure2-regex_19_lookahead.cpp.execution @@ -27,6 +27,14 @@ Running tests_19_lookahead: 26_y: OK regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) parsed_regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) str: aaaaaaaa result_expr: $1 expected_results aaaaaaa 27_y: OK regex: a(?!b(?!c))(..) parsed_regex: a(?!b(?!c))(..) str: abababc result_expr: $1 expected_results bc 28_y: OK regex: a(?!b(?=a))(..) parsed_regex: a(?!b(?=a))(..) str: abababc result_expr: $1 expected_results bc +29_y: OK regex: (?=foo) parsed_regex: (?=foo) str: foo result_expr: @+ expected_results 0 +30_y: OK regex: (?=foo) parsed_regex: (?=foo) str: XfooY result_expr: @+ expected_results 1 +31_y: OK regex: .*(?=foo) parsed_regex: .*(?=foo) str: XfooY result_expr: @+ expected_results 1 +32_y: OK regex: (?=.*P)P parsed_regex: (?=.*P)P str: aP result_expr: @+ expected_results 2 +33_y: OK regex: X(?=foo)f parsed_regex: X(?=foo)f str: ..XfooY.. result_expr: @+ expected_results 4 +34_y: OK regex: X(?=foo) parsed_regex: X(?=foo) str: ..XfooY.. result_expr: @+ expected_results 3 +35_y: OK regex: (?=XY*foo) parsed_regex: (?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 +36_y: OK regex: ^(?=XY*foo) parsed_regex: ^(?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 37_y: OK regex: X(\w+)(?=\s)|X(\w+) parsed_regex: X(\w+)(?=\s)|X(\w+) str: Xab result_expr: [$1-$2] expected_results [-ab] 38_y: OK regex: ^a*(?=b)b parsed_regex: ^a*(?=b)b str: ab result_expr: $& expected_results ab 39_y: OK regex: '(?!\A)x'm parsed_regex: '(?!\A)x'm str: a\nxb\n result_expr: - expected_results - @@ -44,4 +52,6 @@ Running tests_19_lookahead: 51_y: OK regex: ((?s)b.)c(?!\N) parsed_regex: ((?s)b.)c(?!\N) str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 52_y: OK regex: '(b.)c(?!\N)'s parsed_regex: '(b.)c(?!\N)'s str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 53_n: OK regex: a*(?!) parsed_regex: a*(?!) str: aaaab result_expr: - expected_results - +54_y: OK regex: (?)foo parsed_regex: (?)foo str: bar>ABCfoo result_expr: $& expected_results foo +55_y: OK regex: (?ABC)foo parsed_regex: (?ABC)foo str: bar>ABCfoo result_expr: $& expected_results ABCfoo diff --git a/regression-tests/test-results/apple-clang-14-c++2b/pure2-regex_21_atomic_patterns.cpp.execution b/regression-tests/test-results/apple-clang-14-c++2b/pure2-regex_21_atomic_patterns.cpp.execution new file mode 100644 index 0000000000..4812cfbb85 --- /dev/null +++ b/regression-tests/test-results/apple-clang-14-c++2b/pure2-regex_21_atomic_patterns.cpp.execution @@ -0,0 +1,8 @@ +Running tests_21_atomic_patterns: +01_y: OK regex: (?>a+)b parsed_regex: (?>a+)b str: aaab result_expr: - expected_results - +02_y: OK regex: ((?>a+)b) parsed_regex: ((?>a+)b) str: aaab result_expr: $1 expected_results aaab +03_y: OK regex: (?>(a+))b parsed_regex: (?>(a+))b str: aaab result_expr: $1 expected_results aaa +04_y: OK regex: ((?>[^()]+)|\([^()]*\))+ parsed_regex: ((?>[^()]+)|\([^()]*\))+ str: ((abc(ade)ufh()()x result_expr: $& expected_results abc(ade)ufh()()x +05_y: OK regex: round\(((?>[^()]+))\) parsed_regex: round\(((?>[^()]+))\) str: _I(round(xs * sz),1) result_expr: $1 expected_results xs * sz +06_y: OK regex: ^((?>(?:aa)?b)?) parsed_regex: ^((?>(?:aa)?b)?) str: aab result_expr: $1 expected_results aab + diff --git a/regression-tests/test-results/clang-12-c++20/pure2-regex-general.cpp.execution b/regression-tests/test-results/clang-12-c++20/pure2-regex-general.cpp.execution new file mode 100644 index 0000000000..c44d084902 --- /dev/null +++ b/regression-tests/test-results/clang-12-c++20/pure2-regex-general.cpp.execution @@ -0,0 +1,11 @@ +Running tests_01_char_matcher: +Not full match fails: 0 +Full match is ok: 1 +Search finds at position 1: 1 +Search finds at position 3: 3 +Find all finds at position: 1 +Find all finds at position: 4 +Find all finds at position: 7 +Find all found 3 matched: 3 +Find all finds at position: 2 +Find all found 1 match: 1 diff --git a/regression-tests/test-results/clang-12-c++20/pure2-regex_04_start_end.cpp.execution b/regression-tests/test-results/clang-12-c++20/pure2-regex_04_start_end.cpp.execution index 6fef36434a..a1e2b9b631 100644 --- a/regression-tests/test-results/clang-12-c++20/pure2-regex_04_start_end.cpp.execution +++ b/regression-tests/test-results/clang-12-c++20/pure2-regex_04_start_end.cpp.execution @@ -8,4 +8,5 @@ Running tests_04_start_end: 07_y: OK regex: ^ parsed_regex: ^ str: abc result_expr: $& expected_results 08_y: OK regex: $ parsed_regex: $ str: abc result_expr: $& expected_results 09_n: OK regex: $b parsed_regex: $b str: b result_expr: - expected_results - +10_n: OK regex: \GX.*X parsed_regex: \GX.*X str: aaaXbX result_expr: - expected_results - diff --git a/regression-tests/test-results/clang-12-c++20/pure2-regex_19_lookahead.cpp.execution b/regression-tests/test-results/clang-12-c++20/pure2-regex_19_lookahead.cpp.execution index d4c65d951e..0f723eb774 100644 --- a/regression-tests/test-results/clang-12-c++20/pure2-regex_19_lookahead.cpp.execution +++ b/regression-tests/test-results/clang-12-c++20/pure2-regex_19_lookahead.cpp.execution @@ -27,6 +27,14 @@ Running tests_19_lookahead: 26_y: OK regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) parsed_regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) str: aaaaaaaa result_expr: $1 expected_results aaaaaaa 27_y: OK regex: a(?!b(?!c))(..) parsed_regex: a(?!b(?!c))(..) str: abababc result_expr: $1 expected_results bc 28_y: OK regex: a(?!b(?=a))(..) parsed_regex: a(?!b(?=a))(..) str: abababc result_expr: $1 expected_results bc +29_y: OK regex: (?=foo) parsed_regex: (?=foo) str: foo result_expr: @+ expected_results 0 +30_y: OK regex: (?=foo) parsed_regex: (?=foo) str: XfooY result_expr: @+ expected_results 1 +31_y: OK regex: .*(?=foo) parsed_regex: .*(?=foo) str: XfooY result_expr: @+ expected_results 1 +32_y: OK regex: (?=.*P)P parsed_regex: (?=.*P)P str: aP result_expr: @+ expected_results 2 +33_y: OK regex: X(?=foo)f parsed_regex: X(?=foo)f str: ..XfooY.. result_expr: @+ expected_results 4 +34_y: OK regex: X(?=foo) parsed_regex: X(?=foo) str: ..XfooY.. result_expr: @+ expected_results 3 +35_y: OK regex: (?=XY*foo) parsed_regex: (?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 +36_y: OK regex: ^(?=XY*foo) parsed_regex: ^(?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 37_y: OK regex: X(\w+)(?=\s)|X(\w+) parsed_regex: X(\w+)(?=\s)|X(\w+) str: Xab result_expr: [$1-$2] expected_results [-ab] 38_y: OK regex: ^a*(?=b)b parsed_regex: ^a*(?=b)b str: ab result_expr: $& expected_results ab 39_y: OK regex: '(?!\A)x'm parsed_regex: '(?!\A)x'm str: a\nxb\n result_expr: - expected_results - @@ -44,4 +52,6 @@ Running tests_19_lookahead: 51_y: OK regex: ((?s)b.)c(?!\N) parsed_regex: ((?s)b.)c(?!\N) str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 52_y: OK regex: '(b.)c(?!\N)'s parsed_regex: '(b.)c(?!\N)'s str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 53_n: OK regex: a*(?!) parsed_regex: a*(?!) str: aaaab result_expr: - expected_results - +54_y: OK regex: (?)foo parsed_regex: (?)foo str: bar>ABCfoo result_expr: $& expected_results foo +55_y: OK regex: (?ABC)foo parsed_regex: (?ABC)foo str: bar>ABCfoo result_expr: $& expected_results ABCfoo diff --git a/regression-tests/test-results/clang-12-c++20/pure2-regex_21_atomic_patterns.cpp.execution b/regression-tests/test-results/clang-12-c++20/pure2-regex_21_atomic_patterns.cpp.execution new file mode 100644 index 0000000000..4812cfbb85 --- /dev/null +++ b/regression-tests/test-results/clang-12-c++20/pure2-regex_21_atomic_patterns.cpp.execution @@ -0,0 +1,8 @@ +Running tests_21_atomic_patterns: +01_y: OK regex: (?>a+)b parsed_regex: (?>a+)b str: aaab result_expr: - expected_results - +02_y: OK regex: ((?>a+)b) parsed_regex: ((?>a+)b) str: aaab result_expr: $1 expected_results aaab +03_y: OK regex: (?>(a+))b parsed_regex: (?>(a+))b str: aaab result_expr: $1 expected_results aaa +04_y: OK regex: ((?>[^()]+)|\([^()]*\))+ parsed_regex: ((?>[^()]+)|\([^()]*\))+ str: ((abc(ade)ufh()()x result_expr: $& expected_results abc(ade)ufh()()x +05_y: OK regex: round\(((?>[^()]+))\) parsed_regex: round\(((?>[^()]+))\) str: _I(round(xs * sz),1) result_expr: $1 expected_results xs * sz +06_y: OK regex: ^((?>(?:aa)?b)?) parsed_regex: ^((?>(?:aa)?b)?) str: aab result_expr: $1 expected_results aab + diff --git a/regression-tests/test-results/clang-15-c++20-libcpp/pure2-regex-general.cpp.execution b/regression-tests/test-results/clang-15-c++20-libcpp/pure2-regex-general.cpp.execution new file mode 100644 index 0000000000..c44d084902 --- /dev/null +++ b/regression-tests/test-results/clang-15-c++20-libcpp/pure2-regex-general.cpp.execution @@ -0,0 +1,11 @@ +Running tests_01_char_matcher: +Not full match fails: 0 +Full match is ok: 1 +Search finds at position 1: 1 +Search finds at position 3: 3 +Find all finds at position: 1 +Find all finds at position: 4 +Find all finds at position: 7 +Find all found 3 matched: 3 +Find all finds at position: 2 +Find all found 1 match: 1 diff --git a/regression-tests/test-results/clang-15-c++20-libcpp/pure2-regex_04_start_end.cpp.execution b/regression-tests/test-results/clang-15-c++20-libcpp/pure2-regex_04_start_end.cpp.execution index 6fef36434a..a1e2b9b631 100644 --- a/regression-tests/test-results/clang-15-c++20-libcpp/pure2-regex_04_start_end.cpp.execution +++ b/regression-tests/test-results/clang-15-c++20-libcpp/pure2-regex_04_start_end.cpp.execution @@ -8,4 +8,5 @@ Running tests_04_start_end: 07_y: OK regex: ^ parsed_regex: ^ str: abc result_expr: $& expected_results 08_y: OK regex: $ parsed_regex: $ str: abc result_expr: $& expected_results 09_n: OK regex: $b parsed_regex: $b str: b result_expr: - expected_results - +10_n: OK regex: \GX.*X parsed_regex: \GX.*X str: aaaXbX result_expr: - expected_results - diff --git a/regression-tests/test-results/clang-15-c++20-libcpp/pure2-regex_19_lookahead.cpp.execution b/regression-tests/test-results/clang-15-c++20-libcpp/pure2-regex_19_lookahead.cpp.execution index d4c65d951e..0f723eb774 100644 --- a/regression-tests/test-results/clang-15-c++20-libcpp/pure2-regex_19_lookahead.cpp.execution +++ b/regression-tests/test-results/clang-15-c++20-libcpp/pure2-regex_19_lookahead.cpp.execution @@ -27,6 +27,14 @@ Running tests_19_lookahead: 26_y: OK regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) parsed_regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) str: aaaaaaaa result_expr: $1 expected_results aaaaaaa 27_y: OK regex: a(?!b(?!c))(..) parsed_regex: a(?!b(?!c))(..) str: abababc result_expr: $1 expected_results bc 28_y: OK regex: a(?!b(?=a))(..) parsed_regex: a(?!b(?=a))(..) str: abababc result_expr: $1 expected_results bc +29_y: OK regex: (?=foo) parsed_regex: (?=foo) str: foo result_expr: @+ expected_results 0 +30_y: OK regex: (?=foo) parsed_regex: (?=foo) str: XfooY result_expr: @+ expected_results 1 +31_y: OK regex: .*(?=foo) parsed_regex: .*(?=foo) str: XfooY result_expr: @+ expected_results 1 +32_y: OK regex: (?=.*P)P parsed_regex: (?=.*P)P str: aP result_expr: @+ expected_results 2 +33_y: OK regex: X(?=foo)f parsed_regex: X(?=foo)f str: ..XfooY.. result_expr: @+ expected_results 4 +34_y: OK regex: X(?=foo) parsed_regex: X(?=foo) str: ..XfooY.. result_expr: @+ expected_results 3 +35_y: OK regex: (?=XY*foo) parsed_regex: (?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 +36_y: OK regex: ^(?=XY*foo) parsed_regex: ^(?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 37_y: OK regex: X(\w+)(?=\s)|X(\w+) parsed_regex: X(\w+)(?=\s)|X(\w+) str: Xab result_expr: [$1-$2] expected_results [-ab] 38_y: OK regex: ^a*(?=b)b parsed_regex: ^a*(?=b)b str: ab result_expr: $& expected_results ab 39_y: OK regex: '(?!\A)x'm parsed_regex: '(?!\A)x'm str: a\nxb\n result_expr: - expected_results - @@ -44,4 +52,6 @@ Running tests_19_lookahead: 51_y: OK regex: ((?s)b.)c(?!\N) parsed_regex: ((?s)b.)c(?!\N) str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 52_y: OK regex: '(b.)c(?!\N)'s parsed_regex: '(b.)c(?!\N)'s str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 53_n: OK regex: a*(?!) parsed_regex: a*(?!) str: aaaab result_expr: - expected_results - +54_y: OK regex: (?)foo parsed_regex: (?)foo str: bar>ABCfoo result_expr: $& expected_results foo +55_y: OK regex: (?ABC)foo parsed_regex: (?ABC)foo str: bar>ABCfoo result_expr: $& expected_results ABCfoo diff --git a/regression-tests/test-results/clang-15-c++20-libcpp/pure2-regex_21_atomic_patterns.cpp.execution b/regression-tests/test-results/clang-15-c++20-libcpp/pure2-regex_21_atomic_patterns.cpp.execution new file mode 100644 index 0000000000..4812cfbb85 --- /dev/null +++ b/regression-tests/test-results/clang-15-c++20-libcpp/pure2-regex_21_atomic_patterns.cpp.execution @@ -0,0 +1,8 @@ +Running tests_21_atomic_patterns: +01_y: OK regex: (?>a+)b parsed_regex: (?>a+)b str: aaab result_expr: - expected_results - +02_y: OK regex: ((?>a+)b) parsed_regex: ((?>a+)b) str: aaab result_expr: $1 expected_results aaab +03_y: OK regex: (?>(a+))b parsed_regex: (?>(a+))b str: aaab result_expr: $1 expected_results aaa +04_y: OK regex: ((?>[^()]+)|\([^()]*\))+ parsed_regex: ((?>[^()]+)|\([^()]*\))+ str: ((abc(ade)ufh()()x result_expr: $& expected_results abc(ade)ufh()()x +05_y: OK regex: round\(((?>[^()]+))\) parsed_regex: round\(((?>[^()]+))\) str: _I(round(xs * sz),1) result_expr: $1 expected_results xs * sz +06_y: OK regex: ^((?>(?:aa)?b)?) parsed_regex: ^((?>(?:aa)?b)?) str: aab result_expr: $1 expected_results aab + diff --git a/regression-tests/test-results/clang-15-c++20/pure2-regex-general.cpp.execution b/regression-tests/test-results/clang-15-c++20/pure2-regex-general.cpp.execution new file mode 100644 index 0000000000..c44d084902 --- /dev/null +++ b/regression-tests/test-results/clang-15-c++20/pure2-regex-general.cpp.execution @@ -0,0 +1,11 @@ +Running tests_01_char_matcher: +Not full match fails: 0 +Full match is ok: 1 +Search finds at position 1: 1 +Search finds at position 3: 3 +Find all finds at position: 1 +Find all finds at position: 4 +Find all finds at position: 7 +Find all found 3 matched: 3 +Find all finds at position: 2 +Find all found 1 match: 1 diff --git a/regression-tests/test-results/clang-15-c++20/pure2-regex_04_start_end.cpp.execution b/regression-tests/test-results/clang-15-c++20/pure2-regex_04_start_end.cpp.execution index 6fef36434a..a1e2b9b631 100644 --- a/regression-tests/test-results/clang-15-c++20/pure2-regex_04_start_end.cpp.execution +++ b/regression-tests/test-results/clang-15-c++20/pure2-regex_04_start_end.cpp.execution @@ -8,4 +8,5 @@ Running tests_04_start_end: 07_y: OK regex: ^ parsed_regex: ^ str: abc result_expr: $& expected_results 08_y: OK regex: $ parsed_regex: $ str: abc result_expr: $& expected_results 09_n: OK regex: $b parsed_regex: $b str: b result_expr: - expected_results - +10_n: OK regex: \GX.*X parsed_regex: \GX.*X str: aaaXbX result_expr: - expected_results - diff --git a/regression-tests/test-results/clang-15-c++20/pure2-regex_19_lookahead.cpp.execution b/regression-tests/test-results/clang-15-c++20/pure2-regex_19_lookahead.cpp.execution index d4c65d951e..0f723eb774 100644 --- a/regression-tests/test-results/clang-15-c++20/pure2-regex_19_lookahead.cpp.execution +++ b/regression-tests/test-results/clang-15-c++20/pure2-regex_19_lookahead.cpp.execution @@ -27,6 +27,14 @@ Running tests_19_lookahead: 26_y: OK regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) parsed_regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) str: aaaaaaaa result_expr: $1 expected_results aaaaaaa 27_y: OK regex: a(?!b(?!c))(..) parsed_regex: a(?!b(?!c))(..) str: abababc result_expr: $1 expected_results bc 28_y: OK regex: a(?!b(?=a))(..) parsed_regex: a(?!b(?=a))(..) str: abababc result_expr: $1 expected_results bc +29_y: OK regex: (?=foo) parsed_regex: (?=foo) str: foo result_expr: @+ expected_results 0 +30_y: OK regex: (?=foo) parsed_regex: (?=foo) str: XfooY result_expr: @+ expected_results 1 +31_y: OK regex: .*(?=foo) parsed_regex: .*(?=foo) str: XfooY result_expr: @+ expected_results 1 +32_y: OK regex: (?=.*P)P parsed_regex: (?=.*P)P str: aP result_expr: @+ expected_results 2 +33_y: OK regex: X(?=foo)f parsed_regex: X(?=foo)f str: ..XfooY.. result_expr: @+ expected_results 4 +34_y: OK regex: X(?=foo) parsed_regex: X(?=foo) str: ..XfooY.. result_expr: @+ expected_results 3 +35_y: OK regex: (?=XY*foo) parsed_regex: (?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 +36_y: OK regex: ^(?=XY*foo) parsed_regex: ^(?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 37_y: OK regex: X(\w+)(?=\s)|X(\w+) parsed_regex: X(\w+)(?=\s)|X(\w+) str: Xab result_expr: [$1-$2] expected_results [-ab] 38_y: OK regex: ^a*(?=b)b parsed_regex: ^a*(?=b)b str: ab result_expr: $& expected_results ab 39_y: OK regex: '(?!\A)x'm parsed_regex: '(?!\A)x'm str: a\nxb\n result_expr: - expected_results - @@ -44,4 +52,6 @@ Running tests_19_lookahead: 51_y: OK regex: ((?s)b.)c(?!\N) parsed_regex: ((?s)b.)c(?!\N) str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 52_y: OK regex: '(b.)c(?!\N)'s parsed_regex: '(b.)c(?!\N)'s str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 53_n: OK regex: a*(?!) parsed_regex: a*(?!) str: aaaab result_expr: - expected_results - +54_y: OK regex: (?)foo parsed_regex: (?)foo str: bar>ABCfoo result_expr: $& expected_results foo +55_y: OK regex: (?ABC)foo parsed_regex: (?ABC)foo str: bar>ABCfoo result_expr: $& expected_results ABCfoo diff --git a/regression-tests/test-results/clang-15-c++20/pure2-regex_21_atomic_patterns.cpp.execution b/regression-tests/test-results/clang-15-c++20/pure2-regex_21_atomic_patterns.cpp.execution new file mode 100644 index 0000000000..4812cfbb85 --- /dev/null +++ b/regression-tests/test-results/clang-15-c++20/pure2-regex_21_atomic_patterns.cpp.execution @@ -0,0 +1,8 @@ +Running tests_21_atomic_patterns: +01_y: OK regex: (?>a+)b parsed_regex: (?>a+)b str: aaab result_expr: - expected_results - +02_y: OK regex: ((?>a+)b) parsed_regex: ((?>a+)b) str: aaab result_expr: $1 expected_results aaab +03_y: OK regex: (?>(a+))b parsed_regex: (?>(a+))b str: aaab result_expr: $1 expected_results aaa +04_y: OK regex: ((?>[^()]+)|\([^()]*\))+ parsed_regex: ((?>[^()]+)|\([^()]*\))+ str: ((abc(ade)ufh()()x result_expr: $& expected_results abc(ade)ufh()()x +05_y: OK regex: round\(((?>[^()]+))\) parsed_regex: round\(((?>[^()]+))\) str: _I(round(xs * sz),1) result_expr: $1 expected_results xs * sz +06_y: OK regex: ^((?>(?:aa)?b)?) parsed_regex: ^((?>(?:aa)?b)?) str: aab result_expr: $1 expected_results aab + diff --git a/regression-tests/test-results/clang-18-c++20/pure2-regex-general.cpp.output b/regression-tests/test-results/clang-18-c++20/pure2-regex-general.cpp.output new file mode 100644 index 0000000000..40ba2e6c35 --- /dev/null +++ b/regression-tests/test-results/clang-18-c++20/pure2-regex-general.cpp.output @@ -0,0 +1,78 @@ +PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace, preprocessed source, and associated run script. +Stack dump: +0. Program arguments: /usr/lib/llvm-18/bin/clang -cc1 -triple x86_64-pc-linux-gnu -emit-obj -mrelax-all -dumpdir test.exe- -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name pure2-regex-general.cpp -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/home/runner/work/cppfront/cppfront/regression-tests/test-results/clang-18-c++20 -fcoverage-compilation-dir=/home/runner/work/cppfront/cppfront/regression-tests/test-results/clang-18-c++20 -resource-dir /usr/lib/llvm-18/lib/clang/18 -I ../../../include -internal-isystem /usr/bin/../lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14 -internal-isystem /usr/bin/../lib/gcc/x86_64-linux-gnu/14/../../../../include/x86_64-linux-gnu/c++/14 -internal-isystem /usr/bin/../lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14/backward -internal-isystem /usr/lib/llvm-18/lib/clang/18/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -std=c++20 -fdeprecated-macro -ferror-limit 19 -pthread -fgnuc-version=4.2.1 -fno-implicit-modules -fskip-odr-check-in-gmf -fcxx-exceptions -fexceptions -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/pure2-regex-general-8173f8.o -x c++ pure2-regex-general.cpp +1. parser at end of file +2. cpp2regex.h2:833:113: instantiating function definition 'cpp2::regex::regular_expression>::find_all' +3. pure2-regex-general.cpp2:13:16: instantiating function definition 'general_regex_test::run()::(anonymous class)::operator()>::search_return>' +4. pure2-regex-general.cpp2:15:54 : instantiating function definition 'general_regex_test::run()::(anonymous class)::operator()(const cpp2::regex::regular_expression>::search_return &)::(anonymous class)::operator()>::search_return &, int>' + #0 0x00007f4a111a63bf llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (/usr/lib/llvm-18/bin/../lib/libLLVM.so.18.1+0xda63bf) + #1 0x00007f4a111a44f9 llvm::sys::RunSignalHandlers() (/usr/lib/llvm-18/bin/../lib/libLLVM.so.18.1+0xda44f9) + #2 0x00007f4a111a6b00 (/usr/lib/llvm-18/bin/../lib/libLLVM.so.18.1+0xda6b00) + #3 0x00007f4a0fc45320 (/lib/x86_64-linux-gnu/libc.so.6+0x45320) + #4 0x00007f4a19318f6a clang::Sema::tryCaptureVariable(clang::ValueDecl*, clang::SourceLocation, clang::Sema::TryCaptureKind, clang::SourceLocation, bool, clang::QualType&, clang::QualType&, unsigned int const*) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1718f6a) + #5 0x00007f4a192e10a6 clang::Sema::BuildDeclRefExpr(clang::ValueDecl*, clang::QualType, clang::ExprValueKind, clang::DeclarationNameInfo const&, clang::NestedNameSpecifierLoc, clang::NamedDecl*, clang::SourceLocation, clang::TemplateArgumentListInfo const*) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x16e10a6) + #6 0x00007f4a192e1005 clang::Sema::BuildDeclRefExpr(clang::ValueDecl*, clang::QualType, clang::ExprValueKind, clang::DeclarationNameInfo const&, clang::CXXScopeSpec const*, clang::NamedDecl*, clang::SourceLocation, clang::TemplateArgumentListInfo const*) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x16e1005) + #7 0x00007f4a192e533c clang::Sema::BuildDeclarationNameExpr(clang::CXXScopeSpec const&, clang::DeclarationNameInfo const&, clang::NamedDecl*, clang::NamedDecl*, clang::TemplateArgumentListInfo const*, bool) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x16e533c) + #8 0x00007f4a19777871 (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b77871) + #9 0x00007f4a1977abfb (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b7abfb) +#10 0x00007f4a197599c4 (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b599c4) +#11 0x00007f4a19770a28 (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b70a28) +#12 0x00007f4a19760341 (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b60341) +#13 0x00007f4a1976681c (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b6681c) +#14 0x00007f4a1976b4b4 (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b6b4b4) +#15 0x00007f4a1976e08d (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b6e08d) +#16 0x00007f4a1976b4b4 (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b6b4b4) +#17 0x00007f4a19772670 (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b72670) +#18 0x00007f4a19765c77 (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b65c77) +#19 0x00007f4a1978645a (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b8645a) +#20 0x00007f4a1978449f (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b8449f) +#21 0x00007f4a19770669 (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b70669) +#22 0x00007f4a1975fa03 clang::Sema::SubstStmt(clang::Stmt*, clang::MultiLevelTemplateArgumentList const&) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b5fa03) +#23 0x00007f4a197a1f26 clang::Sema::InstantiateFunctionDefinition(clang::SourceLocation, clang::FunctionDecl*, bool, bool, bool) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1ba1f26) +#24 0x00007f4a18fecde0 clang::Sema::runWithSufficientStackSpace(clang::SourceLocation, llvm::function_ref) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x13ecde0) +#25 0x00007f4a1970280e clang::Sema::DeduceReturnType(clang::FunctionDecl*, clang::SourceLocation, bool) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b0280e) +#26 0x00007f4a192d6bc9 clang::Sema::DiagnoseUseOfDecl(clang::NamedDecl*, llvm::ArrayRef, clang::ObjCInterfaceDecl const*, bool, bool, clang::ObjCInterfaceDecl*, bool) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x16d6bc9) +#27 0x00007f4a195de3ce (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x19de3ce) +#28 0x00007f4a195e5884 clang::Sema::BuildCallToObjectOfClassType(clang::Scope*, clang::Expr*, clang::SourceLocation, llvm::MutableArrayRef, clang::SourceLocation) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x19e5884) +#29 0x00007f4a192dbb7d clang::Sema::BuildCallExpr(clang::Scope*, clang::Expr*, clang::SourceLocation, llvm::MutableArrayRef, clang::SourceLocation, clang::Expr*, bool, bool) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x16dbb7d) +#30 0x00007f4a192f60a1 clang::Sema::ActOnCallExpr(clang::Scope*, clang::Expr*, clang::SourceLocation, llvm::MutableArrayRef, clang::SourceLocation, clang::Expr*) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x16f60a1) +#31 0x00007f4a1976b65d (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b6b65d) +#32 0x00007f4a1976f44e (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b6f44e) +#33 0x00007f4a1976f42d (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b6f42d) +#34 0x00007f4a1975fa77 (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b5fa77) +#35 0x00007f4a19770669 (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b70669) +#36 0x00007f4a1975fa03 clang::Sema::SubstStmt(clang::Stmt*, clang::MultiLevelTemplateArgumentList const&) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1b5fa03) +#37 0x00007f4a197a1f26 clang::Sema::InstantiateFunctionDefinition(clang::SourceLocation, clang::FunctionDecl*, bool, bool, bool) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1ba1f26) +#38 0x00007f4a197a4744 clang::Sema::PerformPendingInstantiations(bool) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1ba4744) +#39 0x00007f4a197a2029 clang::Sema::InstantiateFunctionDefinition(clang::SourceLocation, clang::FunctionDecl*, bool, bool, bool) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1ba2029) +#40 0x00007f4a197a4744 clang::Sema::PerformPendingInstantiations(bool) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x1ba4744) +#41 0x00007f4a18fee90b clang::Sema::ActOnEndOfTranslationUnitFragment(clang::Sema::TUFragmentKind) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x13ee90b) +#42 0x00007f4a18feef7b clang::Sema::ActOnEndOfTranslationUnit() (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x13eef7b) +#43 0x00007f4a1885fe2e clang::Parser::ParseTopLevelDecl(clang::OpaquePtr&, clang::Sema::ModuleImportState&) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0xc5fe2e) +#44 0x00007f4a1879747e clang::ParseAST(clang::Sema&, bool, bool) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0xb9747e) +#45 0x00007f4a1a60662c clang::FrontendAction::Execute() (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x2a0662c) +#46 0x00007f4a1a5830b4 clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x29830b4) +#47 0x00007f4a1a68263d clang::ExecuteCompilerInvocation(clang::CompilerInstance*) (/usr/lib/llvm-18/bin/../lib/libclang-cpp.so.18.1+0x2a8263d) +#48 0x000055f3eaf2042e cc1_main(llvm::ArrayRef, char const*, void*) (/usr/lib/llvm-18/bin/clang+0x1442e) +#49 0x000055f3eaf1d894 (/usr/lib/llvm-18/bin/clang+0x11894) +#50 0x000055f3eaf1ca26 clang_main(int, char**, llvm::ToolContext const&) (/usr/lib/llvm-18/bin/clang+0x10a26) +#51 0x000055f3eaf2a383 main (/usr/lib/llvm-18/bin/clang+0x1e383) +#52 0x00007f4a0fc2a1ca (/lib/x86_64-linux-gnu/libc.so.6+0x2a1ca) +#53 0x00007f4a0fc2a28b __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2a28b) +#54 0x000055f3eaf1a255 _start (/usr/lib/llvm-18/bin/clang+0xe255) +clang++-18: error: unable to execute command: Segmentation fault (core dumped) +clang++-18: error: clang frontend command failed due to signal (use -v to see invocation) +Ubuntu clang version 18.1.3 (1ubuntu1) +Target: x86_64-pc-linux-gnu +Thread model: posix +InstalledDir: /usr/bin +clang++-18: note: diagnostic msg: +******************** + +PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT: +Preprocessed source(s) and associated run script(s) are located at: +clang++-18: note: diagnostic msg: /tmp/pure2-regex-general-9097b6.cpp +clang++-18: note: diagnostic msg: /tmp/pure2-regex-general-9097b6.sh +clang++-18: note: diagnostic msg: + +******************** diff --git a/regression-tests/test-results/clang-18-c++20/pure2-regex_04_start_end.cpp.execution b/regression-tests/test-results/clang-18-c++20/pure2-regex_04_start_end.cpp.execution index 6fef36434a..a1e2b9b631 100644 --- a/regression-tests/test-results/clang-18-c++20/pure2-regex_04_start_end.cpp.execution +++ b/regression-tests/test-results/clang-18-c++20/pure2-regex_04_start_end.cpp.execution @@ -8,4 +8,5 @@ Running tests_04_start_end: 07_y: OK regex: ^ parsed_regex: ^ str: abc result_expr: $& expected_results 08_y: OK regex: $ parsed_regex: $ str: abc result_expr: $& expected_results 09_n: OK regex: $b parsed_regex: $b str: b result_expr: - expected_results - +10_n: OK regex: \GX.*X parsed_regex: \GX.*X str: aaaXbX result_expr: - expected_results - diff --git a/regression-tests/test-results/clang-18-c++20/pure2-regex_19_lookahead.cpp.execution b/regression-tests/test-results/clang-18-c++20/pure2-regex_19_lookahead.cpp.execution index d4c65d951e..0f723eb774 100644 --- a/regression-tests/test-results/clang-18-c++20/pure2-regex_19_lookahead.cpp.execution +++ b/regression-tests/test-results/clang-18-c++20/pure2-regex_19_lookahead.cpp.execution @@ -27,6 +27,14 @@ Running tests_19_lookahead: 26_y: OK regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) parsed_regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) str: aaaaaaaa result_expr: $1 expected_results aaaaaaa 27_y: OK regex: a(?!b(?!c))(..) parsed_regex: a(?!b(?!c))(..) str: abababc result_expr: $1 expected_results bc 28_y: OK regex: a(?!b(?=a))(..) parsed_regex: a(?!b(?=a))(..) str: abababc result_expr: $1 expected_results bc +29_y: OK regex: (?=foo) parsed_regex: (?=foo) str: foo result_expr: @+ expected_results 0 +30_y: OK regex: (?=foo) parsed_regex: (?=foo) str: XfooY result_expr: @+ expected_results 1 +31_y: OK regex: .*(?=foo) parsed_regex: .*(?=foo) str: XfooY result_expr: @+ expected_results 1 +32_y: OK regex: (?=.*P)P parsed_regex: (?=.*P)P str: aP result_expr: @+ expected_results 2 +33_y: OK regex: X(?=foo)f parsed_regex: X(?=foo)f str: ..XfooY.. result_expr: @+ expected_results 4 +34_y: OK regex: X(?=foo) parsed_regex: X(?=foo) str: ..XfooY.. result_expr: @+ expected_results 3 +35_y: OK regex: (?=XY*foo) parsed_regex: (?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 +36_y: OK regex: ^(?=XY*foo) parsed_regex: ^(?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 37_y: OK regex: X(\w+)(?=\s)|X(\w+) parsed_regex: X(\w+)(?=\s)|X(\w+) str: Xab result_expr: [$1-$2] expected_results [-ab] 38_y: OK regex: ^a*(?=b)b parsed_regex: ^a*(?=b)b str: ab result_expr: $& expected_results ab 39_y: OK regex: '(?!\A)x'm parsed_regex: '(?!\A)x'm str: a\nxb\n result_expr: - expected_results - @@ -44,4 +52,6 @@ Running tests_19_lookahead: 51_y: OK regex: ((?s)b.)c(?!\N) parsed_regex: ((?s)b.)c(?!\N) str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 52_y: OK regex: '(b.)c(?!\N)'s parsed_regex: '(b.)c(?!\N)'s str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 53_n: OK regex: a*(?!) parsed_regex: a*(?!) str: aaaab result_expr: - expected_results - +54_y: OK regex: (?)foo parsed_regex: (?)foo str: bar>ABCfoo result_expr: $& expected_results foo +55_y: OK regex: (?ABC)foo parsed_regex: (?ABC)foo str: bar>ABCfoo result_expr: $& expected_results ABCfoo diff --git a/regression-tests/test-results/clang-18-c++20/pure2-regex_21_atomic_patterns.cpp.execution b/regression-tests/test-results/clang-18-c++20/pure2-regex_21_atomic_patterns.cpp.execution new file mode 100644 index 0000000000..4812cfbb85 --- /dev/null +++ b/regression-tests/test-results/clang-18-c++20/pure2-regex_21_atomic_patterns.cpp.execution @@ -0,0 +1,8 @@ +Running tests_21_atomic_patterns: +01_y: OK regex: (?>a+)b parsed_regex: (?>a+)b str: aaab result_expr: - expected_results - +02_y: OK regex: ((?>a+)b) parsed_regex: ((?>a+)b) str: aaab result_expr: $1 expected_results aaab +03_y: OK regex: (?>(a+))b parsed_regex: (?>(a+))b str: aaab result_expr: $1 expected_results aaa +04_y: OK regex: ((?>[^()]+)|\([^()]*\))+ parsed_regex: ((?>[^()]+)|\([^()]*\))+ str: ((abc(ade)ufh()()x result_expr: $& expected_results abc(ade)ufh()()x +05_y: OK regex: round\(((?>[^()]+))\) parsed_regex: round\(((?>[^()]+))\) str: _I(round(xs * sz),1) result_expr: $1 expected_results xs * sz +06_y: OK regex: ^((?>(?:aa)?b)?) parsed_regex: ^((?>(?:aa)?b)?) str: aab result_expr: $1 expected_results aab + diff --git a/regression-tests/test-results/gcc-10-c++20/pure2-regex-general.cpp.execution b/regression-tests/test-results/gcc-10-c++20/pure2-regex-general.cpp.execution new file mode 100644 index 0000000000..c44d084902 --- /dev/null +++ b/regression-tests/test-results/gcc-10-c++20/pure2-regex-general.cpp.execution @@ -0,0 +1,11 @@ +Running tests_01_char_matcher: +Not full match fails: 0 +Full match is ok: 1 +Search finds at position 1: 1 +Search finds at position 3: 3 +Find all finds at position: 1 +Find all finds at position: 4 +Find all finds at position: 7 +Find all found 3 matched: 3 +Find all finds at position: 2 +Find all found 1 match: 1 diff --git a/regression-tests/test-results/gcc-10-c++20/pure2-regex_04_start_end.cpp.execution b/regression-tests/test-results/gcc-10-c++20/pure2-regex_04_start_end.cpp.execution index 6fef36434a..a1e2b9b631 100644 --- a/regression-tests/test-results/gcc-10-c++20/pure2-regex_04_start_end.cpp.execution +++ b/regression-tests/test-results/gcc-10-c++20/pure2-regex_04_start_end.cpp.execution @@ -8,4 +8,5 @@ Running tests_04_start_end: 07_y: OK regex: ^ parsed_regex: ^ str: abc result_expr: $& expected_results 08_y: OK regex: $ parsed_regex: $ str: abc result_expr: $& expected_results 09_n: OK regex: $b parsed_regex: $b str: b result_expr: - expected_results - +10_n: OK regex: \GX.*X parsed_regex: \GX.*X str: aaaXbX result_expr: - expected_results - diff --git a/regression-tests/test-results/gcc-10-c++20/pure2-regex_19_lookahead.cpp.execution b/regression-tests/test-results/gcc-10-c++20/pure2-regex_19_lookahead.cpp.execution index d4c65d951e..0f723eb774 100644 --- a/regression-tests/test-results/gcc-10-c++20/pure2-regex_19_lookahead.cpp.execution +++ b/regression-tests/test-results/gcc-10-c++20/pure2-regex_19_lookahead.cpp.execution @@ -27,6 +27,14 @@ Running tests_19_lookahead: 26_y: OK regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) parsed_regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) str: aaaaaaaa result_expr: $1 expected_results aaaaaaa 27_y: OK regex: a(?!b(?!c))(..) parsed_regex: a(?!b(?!c))(..) str: abababc result_expr: $1 expected_results bc 28_y: OK regex: a(?!b(?=a))(..) parsed_regex: a(?!b(?=a))(..) str: abababc result_expr: $1 expected_results bc +29_y: OK regex: (?=foo) parsed_regex: (?=foo) str: foo result_expr: @+ expected_results 0 +30_y: OK regex: (?=foo) parsed_regex: (?=foo) str: XfooY result_expr: @+ expected_results 1 +31_y: OK regex: .*(?=foo) parsed_regex: .*(?=foo) str: XfooY result_expr: @+ expected_results 1 +32_y: OK regex: (?=.*P)P parsed_regex: (?=.*P)P str: aP result_expr: @+ expected_results 2 +33_y: OK regex: X(?=foo)f parsed_regex: X(?=foo)f str: ..XfooY.. result_expr: @+ expected_results 4 +34_y: OK regex: X(?=foo) parsed_regex: X(?=foo) str: ..XfooY.. result_expr: @+ expected_results 3 +35_y: OK regex: (?=XY*foo) parsed_regex: (?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 +36_y: OK regex: ^(?=XY*foo) parsed_regex: ^(?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 37_y: OK regex: X(\w+)(?=\s)|X(\w+) parsed_regex: X(\w+)(?=\s)|X(\w+) str: Xab result_expr: [$1-$2] expected_results [-ab] 38_y: OK regex: ^a*(?=b)b parsed_regex: ^a*(?=b)b str: ab result_expr: $& expected_results ab 39_y: OK regex: '(?!\A)x'm parsed_regex: '(?!\A)x'm str: a\nxb\n result_expr: - expected_results - @@ -44,4 +52,6 @@ Running tests_19_lookahead: 51_y: OK regex: ((?s)b.)c(?!\N) parsed_regex: ((?s)b.)c(?!\N) str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 52_y: OK regex: '(b.)c(?!\N)'s parsed_regex: '(b.)c(?!\N)'s str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 53_n: OK regex: a*(?!) parsed_regex: a*(?!) str: aaaab result_expr: - expected_results - +54_y: OK regex: (?)foo parsed_regex: (?)foo str: bar>ABCfoo result_expr: $& expected_results foo +55_y: OK regex: (?ABC)foo parsed_regex: (?ABC)foo str: bar>ABCfoo result_expr: $& expected_results ABCfoo diff --git a/regression-tests/test-results/gcc-10-c++20/pure2-regex_21_atomic_patterns.cpp.execution b/regression-tests/test-results/gcc-10-c++20/pure2-regex_21_atomic_patterns.cpp.execution new file mode 100644 index 0000000000..4812cfbb85 --- /dev/null +++ b/regression-tests/test-results/gcc-10-c++20/pure2-regex_21_atomic_patterns.cpp.execution @@ -0,0 +1,8 @@ +Running tests_21_atomic_patterns: +01_y: OK regex: (?>a+)b parsed_regex: (?>a+)b str: aaab result_expr: - expected_results - +02_y: OK regex: ((?>a+)b) parsed_regex: ((?>a+)b) str: aaab result_expr: $1 expected_results aaab +03_y: OK regex: (?>(a+))b parsed_regex: (?>(a+))b str: aaab result_expr: $1 expected_results aaa +04_y: OK regex: ((?>[^()]+)|\([^()]*\))+ parsed_regex: ((?>[^()]+)|\([^()]*\))+ str: ((abc(ade)ufh()()x result_expr: $& expected_results abc(ade)ufh()()x +05_y: OK regex: round\(((?>[^()]+))\) parsed_regex: round\(((?>[^()]+))\) str: _I(round(xs * sz),1) result_expr: $1 expected_results xs * sz +06_y: OK regex: ^((?>(?:aa)?b)?) parsed_regex: ^((?>(?:aa)?b)?) str: aab result_expr: $1 expected_results aab + diff --git a/regression-tests/test-results/gcc-13-c++2b/pure2-regex-general.cpp.execution b/regression-tests/test-results/gcc-13-c++2b/pure2-regex-general.cpp.execution new file mode 100644 index 0000000000..c44d084902 --- /dev/null +++ b/regression-tests/test-results/gcc-13-c++2b/pure2-regex-general.cpp.execution @@ -0,0 +1,11 @@ +Running tests_01_char_matcher: +Not full match fails: 0 +Full match is ok: 1 +Search finds at position 1: 1 +Search finds at position 3: 3 +Find all finds at position: 1 +Find all finds at position: 4 +Find all finds at position: 7 +Find all found 3 matched: 3 +Find all finds at position: 2 +Find all found 1 match: 1 diff --git a/regression-tests/test-results/gcc-13-c++2b/pure2-regex_04_start_end.cpp.execution b/regression-tests/test-results/gcc-13-c++2b/pure2-regex_04_start_end.cpp.execution index 6fef36434a..a1e2b9b631 100644 --- a/regression-tests/test-results/gcc-13-c++2b/pure2-regex_04_start_end.cpp.execution +++ b/regression-tests/test-results/gcc-13-c++2b/pure2-regex_04_start_end.cpp.execution @@ -8,4 +8,5 @@ Running tests_04_start_end: 07_y: OK regex: ^ parsed_regex: ^ str: abc result_expr: $& expected_results 08_y: OK regex: $ parsed_regex: $ str: abc result_expr: $& expected_results 09_n: OK regex: $b parsed_regex: $b str: b result_expr: - expected_results - +10_n: OK regex: \GX.*X parsed_regex: \GX.*X str: aaaXbX result_expr: - expected_results - diff --git a/regression-tests/test-results/gcc-13-c++2b/pure2-regex_19_lookahead.cpp.execution b/regression-tests/test-results/gcc-13-c++2b/pure2-regex_19_lookahead.cpp.execution index d4c65d951e..0f723eb774 100644 --- a/regression-tests/test-results/gcc-13-c++2b/pure2-regex_19_lookahead.cpp.execution +++ b/regression-tests/test-results/gcc-13-c++2b/pure2-regex_19_lookahead.cpp.execution @@ -27,6 +27,14 @@ Running tests_19_lookahead: 26_y: OK regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) parsed_regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) str: aaaaaaaa result_expr: $1 expected_results aaaaaaa 27_y: OK regex: a(?!b(?!c))(..) parsed_regex: a(?!b(?!c))(..) str: abababc result_expr: $1 expected_results bc 28_y: OK regex: a(?!b(?=a))(..) parsed_regex: a(?!b(?=a))(..) str: abababc result_expr: $1 expected_results bc +29_y: OK regex: (?=foo) parsed_regex: (?=foo) str: foo result_expr: @+ expected_results 0 +30_y: OK regex: (?=foo) parsed_regex: (?=foo) str: XfooY result_expr: @+ expected_results 1 +31_y: OK regex: .*(?=foo) parsed_regex: .*(?=foo) str: XfooY result_expr: @+ expected_results 1 +32_y: OK regex: (?=.*P)P parsed_regex: (?=.*P)P str: aP result_expr: @+ expected_results 2 +33_y: OK regex: X(?=foo)f parsed_regex: X(?=foo)f str: ..XfooY.. result_expr: @+ expected_results 4 +34_y: OK regex: X(?=foo) parsed_regex: X(?=foo) str: ..XfooY.. result_expr: @+ expected_results 3 +35_y: OK regex: (?=XY*foo) parsed_regex: (?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 +36_y: OK regex: ^(?=XY*foo) parsed_regex: ^(?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 37_y: OK regex: X(\w+)(?=\s)|X(\w+) parsed_regex: X(\w+)(?=\s)|X(\w+) str: Xab result_expr: [$1-$2] expected_results [-ab] 38_y: OK regex: ^a*(?=b)b parsed_regex: ^a*(?=b)b str: ab result_expr: $& expected_results ab 39_y: OK regex: '(?!\A)x'm parsed_regex: '(?!\A)x'm str: a\nxb\n result_expr: - expected_results - @@ -44,4 +52,6 @@ Running tests_19_lookahead: 51_y: OK regex: ((?s)b.)c(?!\N) parsed_regex: ((?s)b.)c(?!\N) str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 52_y: OK regex: '(b.)c(?!\N)'s parsed_regex: '(b.)c(?!\N)'s str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 53_n: OK regex: a*(?!) parsed_regex: a*(?!) str: aaaab result_expr: - expected_results - +54_y: OK regex: (?)foo parsed_regex: (?)foo str: bar>ABCfoo result_expr: $& expected_results foo +55_y: OK regex: (?ABC)foo parsed_regex: (?ABC)foo str: bar>ABCfoo result_expr: $& expected_results ABCfoo diff --git a/regression-tests/test-results/gcc-13-c++2b/pure2-regex_21_atomic_patterns.cpp.execution b/regression-tests/test-results/gcc-13-c++2b/pure2-regex_21_atomic_patterns.cpp.execution new file mode 100644 index 0000000000..4812cfbb85 --- /dev/null +++ b/regression-tests/test-results/gcc-13-c++2b/pure2-regex_21_atomic_patterns.cpp.execution @@ -0,0 +1,8 @@ +Running tests_21_atomic_patterns: +01_y: OK regex: (?>a+)b parsed_regex: (?>a+)b str: aaab result_expr: - expected_results - +02_y: OK regex: ((?>a+)b) parsed_regex: ((?>a+)b) str: aaab result_expr: $1 expected_results aaab +03_y: OK regex: (?>(a+))b parsed_regex: (?>(a+))b str: aaab result_expr: $1 expected_results aaa +04_y: OK regex: ((?>[^()]+)|\([^()]*\))+ parsed_regex: ((?>[^()]+)|\([^()]*\))+ str: ((abc(ade)ufh()()x result_expr: $& expected_results abc(ade)ufh()()x +05_y: OK regex: round\(((?>[^()]+))\) parsed_regex: round\(((?>[^()]+))\) str: _I(round(xs * sz),1) result_expr: $1 expected_results xs * sz +06_y: OK regex: ^((?>(?:aa)?b)?) parsed_regex: ^((?>(?:aa)?b)?) str: aab result_expr: $1 expected_results aab + diff --git a/regression-tests/test-results/gcc-14-c++2b/pure2-regex-general.cpp.execution b/regression-tests/test-results/gcc-14-c++2b/pure2-regex-general.cpp.execution new file mode 100644 index 0000000000..c44d084902 --- /dev/null +++ b/regression-tests/test-results/gcc-14-c++2b/pure2-regex-general.cpp.execution @@ -0,0 +1,11 @@ +Running tests_01_char_matcher: +Not full match fails: 0 +Full match is ok: 1 +Search finds at position 1: 1 +Search finds at position 3: 3 +Find all finds at position: 1 +Find all finds at position: 4 +Find all finds at position: 7 +Find all found 3 matched: 3 +Find all finds at position: 2 +Find all found 1 match: 1 diff --git a/regression-tests/test-results/gcc-14-c++2b/pure2-regex_04_start_end.cpp.execution b/regression-tests/test-results/gcc-14-c++2b/pure2-regex_04_start_end.cpp.execution index 6fef36434a..a1e2b9b631 100644 --- a/regression-tests/test-results/gcc-14-c++2b/pure2-regex_04_start_end.cpp.execution +++ b/regression-tests/test-results/gcc-14-c++2b/pure2-regex_04_start_end.cpp.execution @@ -8,4 +8,5 @@ Running tests_04_start_end: 07_y: OK regex: ^ parsed_regex: ^ str: abc result_expr: $& expected_results 08_y: OK regex: $ parsed_regex: $ str: abc result_expr: $& expected_results 09_n: OK regex: $b parsed_regex: $b str: b result_expr: - expected_results - +10_n: OK regex: \GX.*X parsed_regex: \GX.*X str: aaaXbX result_expr: - expected_results - diff --git a/regression-tests/test-results/gcc-14-c++2b/pure2-regex_19_lookahead.cpp.execution b/regression-tests/test-results/gcc-14-c++2b/pure2-regex_19_lookahead.cpp.execution index d4c65d951e..0f723eb774 100644 --- a/regression-tests/test-results/gcc-14-c++2b/pure2-regex_19_lookahead.cpp.execution +++ b/regression-tests/test-results/gcc-14-c++2b/pure2-regex_19_lookahead.cpp.execution @@ -27,6 +27,14 @@ Running tests_19_lookahead: 26_y: OK regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) parsed_regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) str: aaaaaaaa result_expr: $1 expected_results aaaaaaa 27_y: OK regex: a(?!b(?!c))(..) parsed_regex: a(?!b(?!c))(..) str: abababc result_expr: $1 expected_results bc 28_y: OK regex: a(?!b(?=a))(..) parsed_regex: a(?!b(?=a))(..) str: abababc result_expr: $1 expected_results bc +29_y: OK regex: (?=foo) parsed_regex: (?=foo) str: foo result_expr: @+ expected_results 0 +30_y: OK regex: (?=foo) parsed_regex: (?=foo) str: XfooY result_expr: @+ expected_results 1 +31_y: OK regex: .*(?=foo) parsed_regex: .*(?=foo) str: XfooY result_expr: @+ expected_results 1 +32_y: OK regex: (?=.*P)P parsed_regex: (?=.*P)P str: aP result_expr: @+ expected_results 2 +33_y: OK regex: X(?=foo)f parsed_regex: X(?=foo)f str: ..XfooY.. result_expr: @+ expected_results 4 +34_y: OK regex: X(?=foo) parsed_regex: X(?=foo) str: ..XfooY.. result_expr: @+ expected_results 3 +35_y: OK regex: (?=XY*foo) parsed_regex: (?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 +36_y: OK regex: ^(?=XY*foo) parsed_regex: ^(?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 37_y: OK regex: X(\w+)(?=\s)|X(\w+) parsed_regex: X(\w+)(?=\s)|X(\w+) str: Xab result_expr: [$1-$2] expected_results [-ab] 38_y: OK regex: ^a*(?=b)b parsed_regex: ^a*(?=b)b str: ab result_expr: $& expected_results ab 39_y: OK regex: '(?!\A)x'm parsed_regex: '(?!\A)x'm str: a\nxb\n result_expr: - expected_results - @@ -44,4 +52,6 @@ Running tests_19_lookahead: 51_y: OK regex: ((?s)b.)c(?!\N) parsed_regex: ((?s)b.)c(?!\N) str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 52_y: OK regex: '(b.)c(?!\N)'s parsed_regex: '(b.)c(?!\N)'s str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 53_n: OK regex: a*(?!) parsed_regex: a*(?!) str: aaaab result_expr: - expected_results - +54_y: OK regex: (?)foo parsed_regex: (?)foo str: bar>ABCfoo result_expr: $& expected_results foo +55_y: OK regex: (?ABC)foo parsed_regex: (?ABC)foo str: bar>ABCfoo result_expr: $& expected_results ABCfoo diff --git a/regression-tests/test-results/gcc-14-c++2b/pure2-regex_21_atomic_patterns.cpp.execution b/regression-tests/test-results/gcc-14-c++2b/pure2-regex_21_atomic_patterns.cpp.execution new file mode 100644 index 0000000000..4812cfbb85 --- /dev/null +++ b/regression-tests/test-results/gcc-14-c++2b/pure2-regex_21_atomic_patterns.cpp.execution @@ -0,0 +1,8 @@ +Running tests_21_atomic_patterns: +01_y: OK regex: (?>a+)b parsed_regex: (?>a+)b str: aaab result_expr: - expected_results - +02_y: OK regex: ((?>a+)b) parsed_regex: ((?>a+)b) str: aaab result_expr: $1 expected_results aaab +03_y: OK regex: (?>(a+))b parsed_regex: (?>(a+))b str: aaab result_expr: $1 expected_results aaa +04_y: OK regex: ((?>[^()]+)|\([^()]*\))+ parsed_regex: ((?>[^()]+)|\([^()]*\))+ str: ((abc(ade)ufh()()x result_expr: $& expected_results abc(ade)ufh()()x +05_y: OK regex: round\(((?>[^()]+))\) parsed_regex: round\(((?>[^()]+))\) str: _I(round(xs * sz),1) result_expr: $1 expected_results xs * sz +06_y: OK regex: ^((?>(?:aa)?b)?) parsed_regex: ^((?>(?:aa)?b)?) str: aab result_expr: $1 expected_results aab + diff --git a/regression-tests/test-results/msvc-2022-c++20/pure2-regex-general.cpp.execution b/regression-tests/test-results/msvc-2022-c++20/pure2-regex-general.cpp.execution new file mode 100644 index 0000000000..c44d084902 --- /dev/null +++ b/regression-tests/test-results/msvc-2022-c++20/pure2-regex-general.cpp.execution @@ -0,0 +1,11 @@ +Running tests_01_char_matcher: +Not full match fails: 0 +Full match is ok: 1 +Search finds at position 1: 1 +Search finds at position 3: 3 +Find all finds at position: 1 +Find all finds at position: 4 +Find all finds at position: 7 +Find all found 3 matched: 3 +Find all finds at position: 2 +Find all found 1 match: 1 diff --git a/regression-tests/test-results/msvc-2022-c++20/pure2-regex-general.cpp.output b/regression-tests/test-results/msvc-2022-c++20/pure2-regex-general.cpp.output new file mode 100644 index 0000000000..e8e495e81f --- /dev/null +++ b/regression-tests/test-results/msvc-2022-c++20/pure2-regex-general.cpp.output @@ -0,0 +1 @@ +pure2-regex-general.cpp diff --git a/regression-tests/test-results/msvc-2022-c++20/pure2-regex_04_start_end.cpp.execution b/regression-tests/test-results/msvc-2022-c++20/pure2-regex_04_start_end.cpp.execution index 6fef36434a..a1e2b9b631 100644 --- a/regression-tests/test-results/msvc-2022-c++20/pure2-regex_04_start_end.cpp.execution +++ b/regression-tests/test-results/msvc-2022-c++20/pure2-regex_04_start_end.cpp.execution @@ -8,4 +8,5 @@ Running tests_04_start_end: 07_y: OK regex: ^ parsed_regex: ^ str: abc result_expr: $& expected_results 08_y: OK regex: $ parsed_regex: $ str: abc result_expr: $& expected_results 09_n: OK regex: $b parsed_regex: $b str: b result_expr: - expected_results - +10_n: OK regex: \GX.*X parsed_regex: \GX.*X str: aaaXbX result_expr: - expected_results - diff --git a/regression-tests/test-results/msvc-2022-c++20/pure2-regex_19_lookahead.cpp.execution b/regression-tests/test-results/msvc-2022-c++20/pure2-regex_19_lookahead.cpp.execution index d4c65d951e..0f723eb774 100644 --- a/regression-tests/test-results/msvc-2022-c++20/pure2-regex_19_lookahead.cpp.execution +++ b/regression-tests/test-results/msvc-2022-c++20/pure2-regex_19_lookahead.cpp.execution @@ -27,6 +27,14 @@ Running tests_19_lookahead: 26_y: OK regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) parsed_regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) str: aaaaaaaa result_expr: $1 expected_results aaaaaaa 27_y: OK regex: a(?!b(?!c))(..) parsed_regex: a(?!b(?!c))(..) str: abababc result_expr: $1 expected_results bc 28_y: OK regex: a(?!b(?=a))(..) parsed_regex: a(?!b(?=a))(..) str: abababc result_expr: $1 expected_results bc +29_y: OK regex: (?=foo) parsed_regex: (?=foo) str: foo result_expr: @+ expected_results 0 +30_y: OK regex: (?=foo) parsed_regex: (?=foo) str: XfooY result_expr: @+ expected_results 1 +31_y: OK regex: .*(?=foo) parsed_regex: .*(?=foo) str: XfooY result_expr: @+ expected_results 1 +32_y: OK regex: (?=.*P)P parsed_regex: (?=.*P)P str: aP result_expr: @+ expected_results 2 +33_y: OK regex: X(?=foo)f parsed_regex: X(?=foo)f str: ..XfooY.. result_expr: @+ expected_results 4 +34_y: OK regex: X(?=foo) parsed_regex: X(?=foo) str: ..XfooY.. result_expr: @+ expected_results 3 +35_y: OK regex: (?=XY*foo) parsed_regex: (?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 +36_y: OK regex: ^(?=XY*foo) parsed_regex: ^(?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 37_y: OK regex: X(\w+)(?=\s)|X(\w+) parsed_regex: X(\w+)(?=\s)|X(\w+) str: Xab result_expr: [$1-$2] expected_results [-ab] 38_y: OK regex: ^a*(?=b)b parsed_regex: ^a*(?=b)b str: ab result_expr: $& expected_results ab 39_y: OK regex: '(?!\A)x'm parsed_regex: '(?!\A)x'm str: a\nxb\n result_expr: - expected_results - @@ -44,4 +52,6 @@ Running tests_19_lookahead: 51_y: OK regex: ((?s)b.)c(?!\N) parsed_regex: ((?s)b.)c(?!\N) str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 52_y: OK regex: '(b.)c(?!\N)'s parsed_regex: '(b.)c(?!\N)'s str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 53_n: OK regex: a*(?!) parsed_regex: a*(?!) str: aaaab result_expr: - expected_results - +54_y: OK regex: (?)foo parsed_regex: (?)foo str: bar>ABCfoo result_expr: $& expected_results foo +55_y: OK regex: (?ABC)foo parsed_regex: (?ABC)foo str: bar>ABCfoo result_expr: $& expected_results ABCfoo diff --git a/regression-tests/test-results/msvc-2022-c++20/pure2-regex_21_atomic_patterns.cpp.execution b/regression-tests/test-results/msvc-2022-c++20/pure2-regex_21_atomic_patterns.cpp.execution new file mode 100644 index 0000000000..4812cfbb85 --- /dev/null +++ b/regression-tests/test-results/msvc-2022-c++20/pure2-regex_21_atomic_patterns.cpp.execution @@ -0,0 +1,8 @@ +Running tests_21_atomic_patterns: +01_y: OK regex: (?>a+)b parsed_regex: (?>a+)b str: aaab result_expr: - expected_results - +02_y: OK regex: ((?>a+)b) parsed_regex: ((?>a+)b) str: aaab result_expr: $1 expected_results aaab +03_y: OK regex: (?>(a+))b parsed_regex: (?>(a+))b str: aaab result_expr: $1 expected_results aaa +04_y: OK regex: ((?>[^()]+)|\([^()]*\))+ parsed_regex: ((?>[^()]+)|\([^()]*\))+ str: ((abc(ade)ufh()()x result_expr: $& expected_results abc(ade)ufh()()x +05_y: OK regex: round\(((?>[^()]+))\) parsed_regex: round\(((?>[^()]+))\) str: _I(round(xs * sz),1) result_expr: $1 expected_results xs * sz +06_y: OK regex: ^((?>(?:aa)?b)?) parsed_regex: ^((?>(?:aa)?b)?) str: aab result_expr: $1 expected_results aab + diff --git a/regression-tests/test-results/msvc-2022-c++20/pure2-regex_21_atomic_patterns.cpp.output b/regression-tests/test-results/msvc-2022-c++20/pure2-regex_21_atomic_patterns.cpp.output new file mode 100644 index 0000000000..3d25e76611 --- /dev/null +++ b/regression-tests/test-results/msvc-2022-c++20/pure2-regex_21_atomic_patterns.cpp.output @@ -0,0 +1 @@ +pure2-regex_21_atomic_patterns.cpp diff --git a/regression-tests/test-results/msvc-2022-c++latest/pure2-regex-general.cpp.execution b/regression-tests/test-results/msvc-2022-c++latest/pure2-regex-general.cpp.execution new file mode 100644 index 0000000000..c44d084902 --- /dev/null +++ b/regression-tests/test-results/msvc-2022-c++latest/pure2-regex-general.cpp.execution @@ -0,0 +1,11 @@ +Running tests_01_char_matcher: +Not full match fails: 0 +Full match is ok: 1 +Search finds at position 1: 1 +Search finds at position 3: 3 +Find all finds at position: 1 +Find all finds at position: 4 +Find all finds at position: 7 +Find all found 3 matched: 3 +Find all finds at position: 2 +Find all found 1 match: 1 diff --git a/regression-tests/test-results/msvc-2022-c++latest/pure2-regex-general.cpp.output b/regression-tests/test-results/msvc-2022-c++latest/pure2-regex-general.cpp.output new file mode 100644 index 0000000000..e8e495e81f --- /dev/null +++ b/regression-tests/test-results/msvc-2022-c++latest/pure2-regex-general.cpp.output @@ -0,0 +1 @@ +pure2-regex-general.cpp diff --git a/regression-tests/test-results/msvc-2022-c++latest/pure2-regex_04_start_end.cpp.execution b/regression-tests/test-results/msvc-2022-c++latest/pure2-regex_04_start_end.cpp.execution index 6fef36434a..a1e2b9b631 100644 --- a/regression-tests/test-results/msvc-2022-c++latest/pure2-regex_04_start_end.cpp.execution +++ b/regression-tests/test-results/msvc-2022-c++latest/pure2-regex_04_start_end.cpp.execution @@ -8,4 +8,5 @@ Running tests_04_start_end: 07_y: OK regex: ^ parsed_regex: ^ str: abc result_expr: $& expected_results 08_y: OK regex: $ parsed_regex: $ str: abc result_expr: $& expected_results 09_n: OK regex: $b parsed_regex: $b str: b result_expr: - expected_results - +10_n: OK regex: \GX.*X parsed_regex: \GX.*X str: aaaXbX result_expr: - expected_results - diff --git a/regression-tests/test-results/msvc-2022-c++latest/pure2-regex_19_lookahead.cpp.execution b/regression-tests/test-results/msvc-2022-c++latest/pure2-regex_19_lookahead.cpp.execution index d4c65d951e..0f723eb774 100644 --- a/regression-tests/test-results/msvc-2022-c++latest/pure2-regex_19_lookahead.cpp.execution +++ b/regression-tests/test-results/msvc-2022-c++latest/pure2-regex_19_lookahead.cpp.execution @@ -27,6 +27,14 @@ Running tests_19_lookahead: 26_y: OK regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) parsed_regex: ^(a*?)(?!(aa|aaaa)*$)(?=a\z) str: aaaaaaaa result_expr: $1 expected_results aaaaaaa 27_y: OK regex: a(?!b(?!c))(..) parsed_regex: a(?!b(?!c))(..) str: abababc result_expr: $1 expected_results bc 28_y: OK regex: a(?!b(?=a))(..) parsed_regex: a(?!b(?=a))(..) str: abababc result_expr: $1 expected_results bc +29_y: OK regex: (?=foo) parsed_regex: (?=foo) str: foo result_expr: @+ expected_results 0 +30_y: OK regex: (?=foo) parsed_regex: (?=foo) str: XfooY result_expr: @+ expected_results 1 +31_y: OK regex: .*(?=foo) parsed_regex: .*(?=foo) str: XfooY result_expr: @+ expected_results 1 +32_y: OK regex: (?=.*P)P parsed_regex: (?=.*P)P str: aP result_expr: @+ expected_results 2 +33_y: OK regex: X(?=foo)f parsed_regex: X(?=foo)f str: ..XfooY.. result_expr: @+ expected_results 4 +34_y: OK regex: X(?=foo) parsed_regex: X(?=foo) str: ..XfooY.. result_expr: @+ expected_results 3 +35_y: OK regex: (?=XY*foo) parsed_regex: (?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 +36_y: OK regex: ^(?=XY*foo) parsed_regex: ^(?=XY*foo) str: Xfoo result_expr: @+ expected_results 0 37_y: OK regex: X(\w+)(?=\s)|X(\w+) parsed_regex: X(\w+)(?=\s)|X(\w+) str: Xab result_expr: [$1-$2] expected_results [-ab] 38_y: OK regex: ^a*(?=b)b parsed_regex: ^a*(?=b)b str: ab result_expr: $& expected_results ab 39_y: OK regex: '(?!\A)x'm parsed_regex: '(?!\A)x'm str: a\nxb\n result_expr: - expected_results - @@ -44,4 +52,6 @@ Running tests_19_lookahead: 51_y: OK regex: ((?s)b.)c(?!\N) parsed_regex: ((?s)b.)c(?!\N) str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 52_y: OK regex: '(b.)c(?!\N)'s parsed_regex: '(b.)c(?!\N)'s str: a\nb\nc\n result_expr: $1:$& expected_results b\n:b\nc 53_n: OK regex: a*(?!) parsed_regex: a*(?!) str: aaaab result_expr: - expected_results - +54_y: OK regex: (?)foo parsed_regex: (?)foo str: bar>ABCfoo result_expr: $& expected_results foo +55_y: OK regex: (?ABC)foo parsed_regex: (?ABC)foo str: bar>ABCfoo result_expr: $& expected_results ABCfoo diff --git a/regression-tests/test-results/msvc-2022-c++latest/pure2-regex_21_atomic_patterns.cpp.execution b/regression-tests/test-results/msvc-2022-c++latest/pure2-regex_21_atomic_patterns.cpp.execution new file mode 100644 index 0000000000..4812cfbb85 --- /dev/null +++ b/regression-tests/test-results/msvc-2022-c++latest/pure2-regex_21_atomic_patterns.cpp.execution @@ -0,0 +1,8 @@ +Running tests_21_atomic_patterns: +01_y: OK regex: (?>a+)b parsed_regex: (?>a+)b str: aaab result_expr: - expected_results - +02_y: OK regex: ((?>a+)b) parsed_regex: ((?>a+)b) str: aaab result_expr: $1 expected_results aaab +03_y: OK regex: (?>(a+))b parsed_regex: (?>(a+))b str: aaab result_expr: $1 expected_results aaa +04_y: OK regex: ((?>[^()]+)|\([^()]*\))+ parsed_regex: ((?>[^()]+)|\([^()]*\))+ str: ((abc(ade)ufh()()x result_expr: $& expected_results abc(ade)ufh()()x +05_y: OK regex: round\(((?>[^()]+))\) parsed_regex: round\(((?>[^()]+))\) str: _I(round(xs * sz),1) result_expr: $1 expected_results xs * sz +06_y: OK regex: ^((?>(?:aa)?b)?) parsed_regex: ^((?>(?:aa)?b)?) str: aab result_expr: $1 expected_results aab + diff --git a/regression-tests/test-results/msvc-2022-c++latest/pure2-regex_21_atomic_patterns.cpp.output b/regression-tests/test-results/msvc-2022-c++latest/pure2-regex_21_atomic_patterns.cpp.output new file mode 100644 index 0000000000..3d25e76611 --- /dev/null +++ b/regression-tests/test-results/msvc-2022-c++latest/pure2-regex_21_atomic_patterns.cpp.output @@ -0,0 +1 @@ +pure2-regex_21_atomic_patterns.cpp diff --git a/regression-tests/test-results/pure2-regex-general.cpp b/regression-tests/test-results/pure2-regex-general.cpp new file mode 100644 index 0000000000..599877fa1b --- /dev/null +++ b/regression-tests/test-results/pure2-regex-general.cpp @@ -0,0 +1,236 @@ + +#define CPP2_IMPORT_STD Yes +#include "cpp2regex.h" + +//=== Cpp2 type declarations ==================================================== + + +#include "cpp2util.h" + +#line 1 "pure2-regex-general.cpp2" +class general_regex_test; +#line 2 "pure2-regex-general.cpp2" + + +//=== Cpp2 type definitions and function declarations =========================== + +#line 1 "pure2-regex-general.cpp2" +class general_regex_test { + +#line 4 "pure2-regex-general.cpp2" + public: auto run() const& -> void; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_01_matcher() = default; + public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_01_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_02_matcher() = default; + public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_02_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_02 {}; + public: general_regex_test() = default; + public: general_regex_test(general_regex_test const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(general_regex_test const&) -> void = delete; + + +#line 28 "pure2-regex-general.cpp2" +}; + +auto main() -> int; + +//=== Cpp2 function definitions ================================================= + +#line 1 "pure2-regex-general.cpp2" + +#line 4 "pure2-regex-general.cpp2" + auto general_regex_test::run() const& -> void{ + std::cout << "Running tests_01_char_matcher:" << std::endl; + + std::cout << "Not full match fails: " << CPP2_UFCS(match)(regex_01, "AAaa").matched << std::endl; + std::cout << "Full match is ok: " << CPP2_UFCS(match)(regex_01, "AA").matched << std::endl; + std::cout << "Search finds at position 1: " << CPP2_UFCS(group_start)(CPP2_UFCS(search)(regex_01, "aAAaa"), 0) << std::endl; + std::cout << "Search finds at position 3: " << CPP2_UFCS(group_start)(CPP2_UFCS(search)(regex_01, "aaaAAaa"), 0) << std::endl; + + auto count {0}; + auto func {[&, _1 = (&count)](auto const& r) -> bool{ + *cpp2::impl::assert_not_null(_1) += 1; + std::cout << "Find all finds at position: " << CPP2_UFCS(group_start)(r, 0) << std::endl; + return true; + }}; + + std::string str {"aAAaAAaAAa"}; + regex_01.find_all(func, str); + std::cout << "Find all found 3 matched: " << count << std::endl; + + count = 0; + str = "bbaabb"; + regex_02.find_all(cpp2::move(func), cpp2::move(str)); + std::cout << "Find all found 1 match: " << cpp2::move(count) << std::endl; + } + + + + + template template [[nodiscard]] auto general_regex_test::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"AA"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),2)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,2); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 2;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto general_regex_test::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto general_regex_test::regex_01_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto general_regex_test::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto general_regex_test::regex_01_matcher::to_string() -> std::string{return R"(AA)"; } + + + + + + template template [[nodiscard]] auto general_regex_test::regex_02_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"aa"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),2)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,2); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 2;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto general_regex_test::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto general_regex_test::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto general_regex_test::regex_02_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto general_regex_test::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto general_regex_test::regex_02_matcher::to_string() -> std::string{return R"((?=aa))"; } + + +#line 30 "pure2-regex-general.cpp2" +auto main() -> int{ + CPP2_UFCS(run)(general_regex_test()); +} + diff --git a/regression-tests/test-results/pure2-regex-general.cpp2.output b/regression-tests/test-results/pure2-regex-general.cpp2.output new file mode 100644 index 0000000000..73b5e2c6fd --- /dev/null +++ b/regression-tests/test-results/pure2-regex-general.cpp2.output @@ -0,0 +1,2 @@ +pure2-regex-general.cpp2... ok (all Cpp2, passes safety checks) + diff --git a/regression-tests/test-results/pure2-regex_01_char_matcher.cpp b/regression-tests/test-results/pure2-regex_01_char_matcher.cpp index 28c6a1c57e..24dd28b033 100644 --- a/regression-tests/test-results/pure2-regex_01_char_matcher.cpp +++ b/regression-tests/test-results/pure2-regex_01_char_matcher.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_01_char_matcher.cpp2" -#line 165 "pure2-regex_01_char_matcher.cpp2" +#line 166 "pure2-regex_01_char_matcher.cpp2" class test_tests_01_char_matcher; @@ -18,37 +18,31 @@ class test_tests_01_char_matcher; #line 1 "pure2-regex_01_char_matcher.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_01_char_matcher.cpp2" +#line 113 "pure2-regex_01_char_matcher.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_01_char_matcher.cpp2" +#line 125 "pure2-regex_01_char_matcher.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_01_char_matcher.cpp2" +#line 166 "pure2-regex_01_char_matcher.cpp2" class test_tests_01_char_matcher { -#line 178 "pure2-regex_01_char_matcher.cpp2" +#line 179 "pure2-regex_01_char_matcher.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -56,25 +50,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -82,25 +70,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_02 {}; public: class regex_03_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_03_matcher() = default; public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -108,25 +90,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_03 {}; public: class regex_04_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_04_matcher() = default; public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -134,25 +110,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_04 {}; public: class regex_05_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_05_matcher() = default; public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -160,25 +130,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_05 {}; public: class regex_06_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_06_matcher() = default; public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -186,25 +150,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_06 {}; public: class regex_07_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_06 {}; public: template class regex_07_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_07_matcher() = default; public: regex_07_matcher(regex_07_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -212,25 +170,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_07 {}; public: class regex_08_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_07 {}; public: template class regex_08_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_08_matcher() = default; public: regex_08_matcher(regex_08_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -238,25 +190,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_08 {}; public: class regex_09_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_08 {}; public: template class regex_09_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_09_matcher() = default; public: regex_09_matcher(regex_09_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -264,25 +210,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_09 {}; public: class regex_10_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_09 {}; public: template class regex_10_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_10_matcher() = default; public: regex_10_matcher(regex_10_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -290,25 +230,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_10 {}; public: class regex_11_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_10 {}; public: template class regex_11_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_11_matcher() = default; public: regex_11_matcher(regex_11_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -316,25 +250,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_11 {}; public: class regex_12_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_11 {}; public: template class regex_12_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_12_matcher() = default; public: regex_12_matcher(regex_12_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -342,13 +270,13 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_12 {}; + public: cpp2::regex::regular_expression> regex_12 {}; public: test_tests_01_char_matcher() = default; public: test_tests_01_char_matcher(test_tests_01_char_matcher const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_01_char_matcher const&) -> void = delete; -#line 194 "pure2-regex_01_char_matcher.cpp2" +#line 195 "pure2-regex_01_char_matcher.cpp2" }; auto main() -> int; @@ -452,6 +380,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -467,7 +396,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_01_char_matcher.cpp2" +#line 113 "pure2-regex_01_char_matcher.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -480,7 +409,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_01_char_matcher.cpp2" +#line 125 "pure2-regex_01_char_matcher.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -521,7 +450,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 178 "pure2-regex_01_char_matcher.cpp2" +#line 179 "pure2-regex_01_char_matcher.cpp2" auto test_tests_01_char_matcher::run() const& -> void{ std::cout << "Running tests_01_char_matcher:" << std::endl; test(regex_01, "01", R"(abc)", "abc", "y", R"($&)", "abc"); @@ -542,8 +471,7 @@ template auto test(M const& regex, cpp2::impl::in id, c - - template [[nodiscard]] auto test_tests_01_char_matcher::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -571,10 +499,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -582,19 +511,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_01_char_matcher::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_01_char_matcher::regex_01_matcher::to_string() -> std::string{return R"(abc)"; } + template [[nodiscard]] constexpr auto test_tests_01_char_matcher::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_01_char_matcher::regex_01_matcher::to_string() -> std::string{return R"(abc)"; } - - template [[nodiscard]] auto test_tests_01_char_matcher::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -622,10 +551,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -633,19 +563,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_01_char_matcher::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_01_char_matcher::regex_02_matcher::to_string() -> std::string{return R"(abc)"; } - + template [[nodiscard]] constexpr auto test_tests_01_char_matcher::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_01_char_matcher::regex_02_matcher::to_string() -> std::string{return R"(abc)"; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_03_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -673,10 +603,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_03_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -684,19 +615,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_03_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_01_char_matcher::regex_03_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_01_char_matcher::regex_03_matcher::to_string() -> std::string{return R"(abc)"; } - + template [[nodiscard]] constexpr auto test_tests_01_char_matcher::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_01_char_matcher::regex_03_matcher::to_string() -> std::string{return R"(abc)"; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_04_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -724,10 +655,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_04_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -735,19 +667,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_04_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_01_char_matcher::regex_04_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_01_char_matcher::regex_04_matcher::to_string() -> std::string{return R"(abc)"; } + template [[nodiscard]] constexpr auto test_tests_01_char_matcher::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_01_char_matcher::regex_04_matcher::to_string() -> std::string{return R"(abc)"; } - - template [[nodiscard]] auto test_tests_01_char_matcher::regex_05_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -775,10 +707,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_05_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -786,19 +719,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_05_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_01_char_matcher::regex_05_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_01_char_matcher::regex_05_matcher::to_string() -> std::string{return R"(abc)"; } - + template [[nodiscard]] constexpr auto test_tests_01_char_matcher::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_01_char_matcher::regex_05_matcher::to_string() -> std::string{return R"(abc)"; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_06_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -826,10 +759,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_06_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -837,19 +771,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_06_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_01_char_matcher::regex_06_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_01_char_matcher::regex_06_matcher::to_string() -> std::string{return R"(abc)"; } - + template [[nodiscard]] constexpr auto test_tests_01_char_matcher::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_01_char_matcher::regex_06_matcher::to_string() -> std::string{return R"(abc)"; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_07_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_07_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -877,10 +811,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_07_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_07_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -888,19 +823,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_07_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_01_char_matcher::regex_07_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_01_char_matcher::regex_07_matcher::to_string() -> std::string{return R"(abc)"; } + template [[nodiscard]] constexpr auto test_tests_01_char_matcher::regex_07_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_01_char_matcher::regex_07_matcher::to_string() -> std::string{return R"(abc)"; } - - template [[nodiscard]] auto test_tests_01_char_matcher::regex_08_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_08_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -928,10 +863,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_08_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_08_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -939,19 +875,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_08_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_01_char_matcher::regex_08_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_01_char_matcher::regex_08_matcher::to_string() -> std::string{return R"(abc)"; } - + template [[nodiscard]] constexpr auto test_tests_01_char_matcher::regex_08_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_01_char_matcher::regex_08_matcher::to_string() -> std::string{return R"(abc)"; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_09_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_09_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -979,10 +915,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_09_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_09_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -990,19 +927,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_09_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_01_char_matcher::regex_09_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_01_char_matcher::regex_09_matcher::to_string() -> std::string{return R"(abc)"; } - + template [[nodiscard]] constexpr auto test_tests_01_char_matcher::regex_09_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_01_char_matcher::regex_09_matcher::to_string() -> std::string{return R"(abc)"; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_10_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_10_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1030,10 +967,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_10_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_10_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1041,19 +979,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_10_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_01_char_matcher::regex_10_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_01_char_matcher::regex_10_matcher::to_string() -> std::string{return R"(abc)"; } + template [[nodiscard]] constexpr auto test_tests_01_char_matcher::regex_10_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_01_char_matcher::regex_10_matcher::to_string() -> std::string{return R"(abc)"; } - - template [[nodiscard]] auto test_tests_01_char_matcher::regex_11_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_11_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1081,10 +1019,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_11_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_11_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1092,19 +1031,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_11_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_01_char_matcher::regex_11_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_01_char_matcher::regex_11_matcher::to_string() -> std::string{return R"(abc)"; } - + template [[nodiscard]] constexpr auto test_tests_01_char_matcher::regex_11_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_01_char_matcher::regex_11_matcher::to_string() -> std::string{return R"(abc)"; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_12_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_12_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1132,10 +1071,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_12_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_01_char_matcher::regex_12_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1143,15 +1083,16 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_01_char_matcher::regex_12_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_01_char_matcher::regex_12_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_01_char_matcher::regex_12_matcher::to_string() -> std::string{return R"(abc)"; } + template [[nodiscard]] constexpr auto test_tests_01_char_matcher::regex_12_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_01_char_matcher::regex_12_matcher::to_string() -> std::string{return R"(abc)"; } -#line 195 "pure2-regex_01_char_matcher.cpp2" +#line 196 "pure2-regex_01_char_matcher.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_01_char_matcher()); } diff --git a/regression-tests/test-results/pure2-regex_02_ranges.cpp b/regression-tests/test-results/pure2-regex_02_ranges.cpp index ba9e6eef57..58a42c8bf5 100644 --- a/regression-tests/test-results/pure2-regex_02_ranges.cpp +++ b/regression-tests/test-results/pure2-regex_02_ranges.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_02_ranges.cpp2" -#line 165 "pure2-regex_02_ranges.cpp2" +#line 166 "pure2-regex_02_ranges.cpp2" class test_tests_02_ranges; @@ -18,47 +18,41 @@ class test_tests_02_ranges; #line 1 "pure2-regex_02_ranges.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_02_ranges.cpp2" +#line 113 "pure2-regex_02_ranges.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_02_ranges.cpp2" +#line 125 "pure2-regex_02_ranges.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_02_ranges.cpp2" +#line 166 "pure2-regex_02_ranges.cpp2" class test_tests_02_ranges { -#line 206 "pure2-regex_02_ranges.cpp2" +#line 207 "pure2-regex_02_ranges.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -66,35 +60,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -102,35 +90,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_02 {}; public: class regex_03_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_03_matcher() = default; public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -138,35 +120,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_03 {}; public: class regex_04_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_04_matcher() = default; public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -174,35 +150,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_04 {}; public: class regex_05_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_05_matcher() = default; public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -210,35 +180,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_05 {}; public: class regex_06_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_06_matcher() = default; public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -246,35 +210,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_06 {}; public: class regex_07_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_06 {}; public: template class regex_07_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_07_matcher() = default; public: regex_07_matcher(regex_07_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -282,35 +240,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_07 {}; public: class regex_08_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_07 {}; public: template class regex_08_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_08_matcher() = default; public: regex_08_matcher(regex_08_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -318,35 +270,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_08 {}; public: class regex_09_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_08 {}; public: template class regex_09_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_09_matcher() = default; public: regex_09_matcher(regex_09_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -354,35 +300,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_09 {}; public: class regex_10_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_09 {}; public: template class regex_10_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_10_matcher() = default; public: regex_10_matcher(regex_10_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -390,35 +330,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_10 {}; public: class regex_11_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_10 {}; public: template class regex_11_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_11_matcher() = default; public: regex_11_matcher(regex_11_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -426,35 +360,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_11 {}; public: class regex_12_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_11 {}; public: template class regex_12_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_12_matcher() = default; public: regex_12_matcher(regex_12_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -462,35 +390,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_12 {}; public: class regex_13_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_12 {}; public: template class regex_13_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_13_matcher() = default; public: regex_13_matcher(regex_13_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -498,35 +420,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_13 {}; public: class regex_14_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_13 {}; public: template class regex_14_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_14_matcher() = default; public: regex_14_matcher(regex_14_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -534,35 +450,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_14 {}; public: class regex_15_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_14 {}; public: template class regex_15_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_15_matcher() = default; public: regex_15_matcher(regex_15_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -570,35 +480,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_15 {}; public: class regex_16_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_15 {}; public: template class regex_16_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_16_matcher() = default; public: regex_16_matcher(regex_16_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -606,35 +510,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_16 {}; public: class regex_17_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_16 {}; public: template class regex_17_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_17_matcher() = default; public: regex_17_matcher(regex_17_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -642,35 +540,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_17 {}; public: class regex_18_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_17 {}; public: template class regex_18_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_18_matcher() = default; public: regex_18_matcher(regex_18_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -678,35 +570,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_18 {}; public: class regex_19_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_18 {}; public: template class regex_19_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_19_matcher() = default; public: regex_19_matcher(regex_19_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -714,35 +600,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_19 {}; public: class regex_20_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_19 {}; public: template class regex_20_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_20_matcher() = default; public: regex_20_matcher(regex_20_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -750,35 +630,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_20 {}; public: class regex_21_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_20 {}; public: template class regex_21_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_21_matcher() = default; public: regex_21_matcher(regex_21_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -786,35 +660,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_21 {}; public: class regex_22_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_21 {}; public: template class regex_22_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_22_matcher() = default; public: regex_22_matcher(regex_22_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -822,35 +690,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_22 {}; public: class regex_23_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_22 {}; public: template class regex_23_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_23_matcher() = default; public: regex_23_matcher(regex_23_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -858,35 +720,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_23 {}; public: class regex_24_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_23 {}; public: template class regex_24_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_24_matcher() = default; public: regex_24_matcher(regex_24_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -894,35 +750,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_24 {}; public: class regex_25_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_24 {}; public: template class regex_25_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_25_matcher() = default; public: regex_25_matcher(regex_25_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -930,35 +780,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_25 {}; public: class regex_26_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_25 {}; public: template class regex_26_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_26_matcher() = default; public: regex_26_matcher(regex_26_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -966,35 +810,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_26 {}; public: class regex_27_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_26 {}; public: template class regex_27_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_27_matcher() = default; public: regex_27_matcher(regex_27_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1002,35 +840,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_27 {}; public: class regex_28_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_27 {}; public: template class regex_28_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_28_matcher() = default; public: regex_28_matcher(regex_28_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1038,35 +870,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_28 {}; public: class regex_29_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_28 {}; public: template class regex_29_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_29_matcher() = default; public: regex_29_matcher(regex_29_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1074,35 +900,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_29 {}; public: class regex_30_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_29 {}; public: template class regex_30_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_30_matcher() = default; public: regex_30_matcher(regex_30_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1110,35 +930,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_30 {}; public: class regex_31_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_30 {}; public: template class regex_31_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_31_matcher() = default; public: regex_31_matcher(regex_31_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1146,35 +960,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_31 {}; public: class regex_32_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_31 {}; public: template class regex_32_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_32_matcher() = default; public: regex_32_matcher(regex_32_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1182,35 +990,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_32 {}; public: class regex_33_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_32 {}; public: template class regex_33_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_33_matcher() = default; public: regex_33_matcher(regex_33_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1218,35 +1020,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_33 {}; public: class regex_34_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_33 {}; public: template class regex_34_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_34_matcher() = default; public: regex_34_matcher(regex_34_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1254,35 +1050,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_34 {}; public: class regex_35_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_34 {}; public: template class regex_35_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_35_matcher() = default; public: regex_35_matcher(regex_35_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1290,35 +1080,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_35 {}; public: class regex_36_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_35 {}; public: template class regex_36_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_36_matcher() = default; public: regex_36_matcher(regex_36_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1326,35 +1110,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_36 {}; public: class regex_37_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_36 {}; public: template class regex_37_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_37_matcher() = default; public: regex_37_matcher(regex_37_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1362,35 +1140,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_37 {}; public: class regex_38_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_37 {}; public: template class regex_38_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_38_matcher() = default; public: regex_38_matcher(regex_38_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1398,35 +1170,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_38 {}; public: class regex_39_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_38 {}; public: template class regex_39_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_39_matcher() = default; public: regex_39_matcher(regex_39_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1434,35 +1200,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_39 {}; public: class regex_40_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_39 {}; public: template class regex_40_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_40_matcher() = default; public: regex_40_matcher(regex_40_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1470,13 +1230,13 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_40 {}; + public: cpp2::regex::regular_expression> regex_40 {}; public: test_tests_02_ranges() = default; public: test_tests_02_ranges(test_tests_02_ranges const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_02_ranges const&) -> void = delete; -#line 250 "pure2-regex_02_ranges.cpp2" +#line 251 "pure2-regex_02_ranges.cpp2" }; auto main() -> int; @@ -1580,6 +1340,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -1595,7 +1356,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_02_ranges.cpp2" +#line 113 "pure2-regex_02_ranges.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -1608,7 +1369,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_02_ranges.cpp2" +#line 125 "pure2-regex_02_ranges.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -1649,7 +1410,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 206 "pure2-regex_02_ranges.cpp2" +#line 207 "pure2-regex_02_ranges.cpp2" auto test_tests_02_ranges::run() const& -> void{ std::cout << "Running tests_02_ranges:" << std::endl; test(regex_01, "01", R"(ab*c)", "abc", "y", R"($&)", "abc"); @@ -1698,8 +1459,7 @@ template auto test(M const& regex, cpp2::impl::in id, c - - template [[nodiscard]] auto test_tests_02_ranges::regex_01_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_01_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1727,11 +1487,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1759,11 +1520,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_01_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_01_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1791,10 +1553,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1802,19 +1565,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_01_matcher::to_string() -> std::string{return R"(ab*c)"; } + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_01_matcher::to_string() -> std::string{return R"(ab*c)"; } - - template [[nodiscard]] auto test_tests_02_ranges::regex_02_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_02_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1842,11 +1605,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1874,11 +1638,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_02_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_02_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1906,10 +1671,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1917,19 +1683,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_02_matcher::to_string() -> std::string{return R"(ab*c)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_02_matcher::to_string() -> std::string{return R"(ab*c)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_03_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_03_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1957,11 +1723,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_03_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1989,11 +1756,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_03_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_03_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2021,10 +1789,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_03_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2032,19 +1801,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_03_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_03_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_03_matcher::to_string() -> std::string{return R"(ab*c)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_03_matcher::to_string() -> std::string{return R"(ab*c)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_04_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_04_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2072,11 +1841,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_04_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2104,11 +1874,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_04_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_04_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2136,10 +1907,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_04_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2147,19 +1919,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_04_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_04_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_04_matcher::to_string() -> std::string{return R"(ab*bc)"; } + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_04_matcher::to_string() -> std::string{return R"(ab*bc)"; } - - template [[nodiscard]] auto test_tests_02_ranges::regex_05_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_05_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2187,11 +1959,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_05_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2219,11 +1992,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_05_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_05_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2251,10 +2025,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_05_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2262,19 +2037,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_05_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_05_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_05_matcher::to_string() -> std::string{return R"(ab*bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_05_matcher::to_string() -> std::string{return R"(ab*bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_06_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_06_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2302,11 +2077,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_06_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2334,11 +2110,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_06_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_06_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2366,10 +2143,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_06_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2377,19 +2155,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_06_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_06_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_06_matcher::to_string() -> std::string{return R"(ab*bc)"; } + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_06_matcher::to_string() -> std::string{return R"(ab*bc)"; } - - template [[nodiscard]] auto test_tests_02_ranges::regex_07_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_07_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2417,11 +2195,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_07_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_07_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2449,11 +2228,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_07_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_07_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2481,10 +2261,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_07_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_07_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2492,19 +2273,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_07_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_07_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_07_matcher::to_string() -> std::string{return R"(ab*bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_07_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_07_matcher::to_string() -> std::string{return R"(ab*bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_08_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_08_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2532,11 +2313,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_08_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_08_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2564,11 +2346,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_08_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_08_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2596,10 +2379,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_08_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_08_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2607,19 +2391,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_08_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_08_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_08_matcher::to_string() -> std::string{return R"(ab*bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_08_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_08_matcher::to_string() -> std::string{return R"(ab*bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_09_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_09_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2647,11 +2431,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_09_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_09_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2679,11 +2464,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_09_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_09_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2711,10 +2497,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_09_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_09_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2722,19 +2509,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_09_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_09_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_09_matcher::to_string() -> std::string{return R"(ab*bc)"; } + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_09_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_09_matcher::to_string() -> std::string{return R"(ab*bc)"; } - - template [[nodiscard]] auto test_tests_02_ranges::regex_10_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_10_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2762,11 +2549,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_10_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_10_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2794,11 +2582,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_10_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_10_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2826,10 +2615,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_10_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_10_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2837,19 +2627,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_10_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_10_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_10_matcher::to_string() -> std::string{return R"(ab*bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_10_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_10_matcher::to_string() -> std::string{return R"(ab*bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_11_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_11_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2877,11 +2667,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_11_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_11_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2909,11 +2700,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_11_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_11_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2941,10 +2733,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_11_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_11_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2952,19 +2745,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_11_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_11_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_11_matcher::to_string() -> std::string{return R"(ab*bc)"; } + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_11_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_11_matcher::to_string() -> std::string{return R"(ab*bc)"; } - - template [[nodiscard]] auto test_tests_02_ranges::regex_12_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_12_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2992,11 +2785,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_12_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_12_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3024,11 +2818,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_12_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_12_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3056,10 +2851,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_12_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_12_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3067,19 +2863,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_12_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_12_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_12_matcher::to_string() -> std::string{return R"(ab*bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_12_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_12_matcher::to_string() -> std::string{return R"(ab*bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_13_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_13_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3107,11 +2903,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_13_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_13_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3139,11 +2936,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_13_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_13_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3171,10 +2969,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_13_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_13_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3182,19 +2981,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_13_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_13_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_13_matcher::to_string() -> std::string{return R"(ab{0,}bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_13_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_13_matcher::to_string() -> std::string{return R"(ab{0,}bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_14_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_14_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3222,11 +3021,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_14_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_14_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3254,11 +3054,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_14_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_14_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3286,10 +3087,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_14_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_14_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3297,19 +3099,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_14_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_14_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_14_matcher::to_string() -> std::string{return R"(ab{0,}bc)"; } + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_14_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_14_matcher::to_string() -> std::string{return R"(ab{0,}bc)"; } - - template [[nodiscard]] auto test_tests_02_ranges::regex_15_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_15_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3337,11 +3139,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_15_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_15_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3369,11 +3172,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_15_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_15_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3401,10 +3205,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_15_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_15_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3412,19 +3217,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_15_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_15_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_15_matcher::to_string() -> std::string{return R"(ab{0,}bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_15_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_15_matcher::to_string() -> std::string{return R"(ab{0,}bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_16_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_16_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3452,11 +3257,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_16_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_16_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3484,11 +3290,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_16_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_16_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3516,10 +3323,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_16_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_16_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3527,19 +3335,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_16_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_16_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_16_matcher::to_string() -> std::string{return R"(ab+bc)"; } + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_16_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_16_matcher::to_string() -> std::string{return R"(ab+bc)"; } - - template [[nodiscard]] auto test_tests_02_ranges::regex_17_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_17_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3567,11 +3375,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_17_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_17_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3599,11 +3408,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_17_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_17_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3631,10 +3441,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_17_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_17_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3642,19 +3453,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_17_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_17_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_17_matcher::to_string() -> std::string{return R"(ab+bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_17_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_17_matcher::to_string() -> std::string{return R"(ab+bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_18_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_18_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3682,11 +3493,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_18_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_18_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3714,11 +3526,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_18_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_18_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3746,10 +3559,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_18_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_18_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3757,19 +3571,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_18_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_18_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_18_matcher::to_string() -> std::string{return R"(ab+bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_18_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_18_matcher::to_string() -> std::string{return R"(ab+bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_19_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_19_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3797,11 +3611,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_19_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_19_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3829,11 +3644,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_19_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_19_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3861,10 +3677,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_19_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_19_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3872,19 +3689,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_19_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_19_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_19_matcher::to_string() -> std::string{return R"(ab+bc)"; } + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_19_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_19_matcher::to_string() -> std::string{return R"(ab+bc)"; } - - template [[nodiscard]] auto test_tests_02_ranges::regex_20_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_20_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3912,11 +3729,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_20_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_20_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3944,11 +3762,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_20_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_20_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3976,10 +3795,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_20_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_20_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3987,19 +3807,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_20_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_20_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_20_matcher::to_string() -> std::string{return R"(ab+bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_20_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_20_matcher::to_string() -> std::string{return R"(ab+bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_21_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_21_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4027,11 +3847,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_21_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_21_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4059,11 +3880,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_21_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_21_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4091,10 +3913,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_21_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_21_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4102,19 +3925,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_21_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_21_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_21_matcher::to_string() -> std::string{return R"(ab{1,}bc)"; } + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_21_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_21_matcher::to_string() -> std::string{return R"(ab{1,}bc)"; } - - template [[nodiscard]] auto test_tests_02_ranges::regex_22_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_22_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4142,11 +3965,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_22_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_22_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4174,11 +3998,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_22_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_22_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4206,10 +4031,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_22_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_22_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4217,19 +4043,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_22_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_22_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_22_matcher::to_string() -> std::string{return R"(ab+bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_22_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_22_matcher::to_string() -> std::string{return R"(ab+bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_23_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_23_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4257,11 +4083,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_23_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_23_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4289,11 +4116,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_23_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_23_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4321,10 +4149,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_23_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_23_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4332,19 +4161,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_23_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_23_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_23_matcher::to_string() -> std::string{return R"(ab+bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_23_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_23_matcher::to_string() -> std::string{return R"(ab+bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_24_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_24_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4372,11 +4201,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_24_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_24_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4404,11 +4234,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_24_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_24_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4436,10 +4267,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_24_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_24_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4447,19 +4279,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_24_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_24_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_24_matcher::to_string() -> std::string{return R"(ab+bc)"; } + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_24_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_24_matcher::to_string() -> std::string{return R"(ab+bc)"; } - - template [[nodiscard]] auto test_tests_02_ranges::regex_25_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_25_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4487,11 +4319,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_25_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_25_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4519,11 +4352,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_25_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_25_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4551,10 +4385,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_25_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_25_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4562,19 +4397,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_25_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_25_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_25_matcher::to_string() -> std::string{return R"(ab{1,}bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_25_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_25_matcher::to_string() -> std::string{return R"(ab{1,}bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_26_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_26_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4602,11 +4437,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_26_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_26_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4634,11 +4470,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_26_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_26_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4666,10 +4503,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_26_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_26_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4677,19 +4515,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_26_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_26_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_26_matcher::to_string() -> std::string{return R"(ab{1,}bc)"; } + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_26_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_26_matcher::to_string() -> std::string{return R"(ab{1,}bc)"; } - - template [[nodiscard]] auto test_tests_02_ranges::regex_27_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_27_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4717,11 +4555,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_27_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_27_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4749,11 +4588,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_27_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_27_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4781,10 +4621,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_27_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_27_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4792,19 +4633,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_27_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_27_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_27_matcher::to_string() -> std::string{return R"(ab{1,}bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_27_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_27_matcher::to_string() -> std::string{return R"(ab{1,}bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_28_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_28_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4832,11 +4673,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_28_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_28_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4864,11 +4706,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_28_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_28_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4896,10 +4739,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_28_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_28_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4907,19 +4751,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_28_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_28_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_28_matcher::to_string() -> std::string{return R"(ab{1,3}bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_28_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_28_matcher::to_string() -> std::string{return R"(ab{1,3}bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_29_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_29_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4947,11 +4791,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_29_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_29_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4979,11 +4824,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_29_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_29_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5011,10 +4857,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_29_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_29_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5022,19 +4869,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_29_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_29_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_29_matcher::to_string() -> std::string{return R"(ab{1,3}bc)"; } + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_29_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_29_matcher::to_string() -> std::string{return R"(ab{1,3}bc)"; } - - template [[nodiscard]] auto test_tests_02_ranges::regex_30_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_30_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5062,11 +4909,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_30_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_30_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5094,11 +4942,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_30_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_30_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5126,10 +4975,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_30_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_30_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5137,19 +4987,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_30_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_30_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_30_matcher::to_string() -> std::string{return R"(ab{1,3}bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_30_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_30_matcher::to_string() -> std::string{return R"(ab{1,3}bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_31_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_31_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5177,11 +5027,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_31_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_31_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5209,11 +5060,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_31_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_31_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5241,10 +5093,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_31_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_31_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5252,19 +5105,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_31_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_31_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_31_matcher::to_string() -> std::string{return R"(ab{3,4}bc)"; } + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_31_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_31_matcher::to_string() -> std::string{return R"(ab{3,4}bc)"; } - - template [[nodiscard]] auto test_tests_02_ranges::regex_32_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_32_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5292,11 +5145,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_32_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_32_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5324,11 +5178,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_32_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_32_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5356,10 +5211,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_32_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_32_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5367,19 +5223,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_32_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_32_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_32_matcher::to_string() -> std::string{return R"(ab{3,4}bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_32_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_32_matcher::to_string() -> std::string{return R"(ab{3,4}bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_33_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_33_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5407,11 +5263,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_33_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_33_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5439,11 +5296,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_33_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_33_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5471,10 +5329,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_33_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_33_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5482,19 +5341,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_33_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_33_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_33_matcher::to_string() -> std::string{return R"(ab{3,4}bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_33_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_33_matcher::to_string() -> std::string{return R"(ab{3,4}bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_34_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_34_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5522,11 +5381,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_34_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_34_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5554,11 +5414,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_34_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_34_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5586,10 +5447,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_34_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_34_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5597,19 +5459,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_34_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_34_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_34_matcher::to_string() -> std::string{return R"(ab{4,5}bc)"; } + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_34_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_34_matcher::to_string() -> std::string{return R"(ab{4,5}bc)"; } - - template [[nodiscard]] auto test_tests_02_ranges::regex_35_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_35_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5637,11 +5499,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_35_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_35_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5669,11 +5532,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_35_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_35_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5701,10 +5565,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_35_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_35_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5712,19 +5577,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_35_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_35_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_35_matcher::to_string() -> std::string{return R"(ab?bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_35_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_35_matcher::to_string() -> std::string{return R"(ab?bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_36_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_36_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5752,11 +5617,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_36_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_36_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5784,11 +5650,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_36_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_36_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5816,10 +5683,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_36_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_36_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5827,19 +5695,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_36_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_36_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_36_matcher::to_string() -> std::string{return R"(ab?bc)"; } + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_36_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_36_matcher::to_string() -> std::string{return R"(ab?bc)"; } - - template [[nodiscard]] auto test_tests_02_ranges::regex_37_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_37_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5867,11 +5735,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_37_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_37_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5899,11 +5768,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_37_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_37_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5931,10 +5801,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_37_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_37_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5942,19 +5813,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_37_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_37_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_37_matcher::to_string() -> std::string{return R"(ab{0,1}bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_37_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_37_matcher::to_string() -> std::string{return R"(ab{0,1}bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_38_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_38_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5982,11 +5853,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_38_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_38_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6014,11 +5886,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_38_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_38_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6046,10 +5919,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_38_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_38_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6057,19 +5931,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_38_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_38_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_38_matcher::to_string() -> std::string{return R"(ab?bc)"; } - + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_38_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_38_matcher::to_string() -> std::string{return R"(ab?bc)"; } - template [[nodiscard]] auto test_tests_02_ranges::regex_39_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_39_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6097,11 +5971,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_39_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_39_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6129,11 +6004,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_39_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_39_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6161,10 +6037,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_39_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_39_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6172,19 +6049,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_39_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_39_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_39_matcher::to_string() -> std::string{return R"(ab?c)"; } + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_39_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_39_matcher::to_string() -> std::string{return R"(ab?c)"; } - - template [[nodiscard]] auto test_tests_02_ranges::regex_40_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_40_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6212,11 +6089,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_40_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_40_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6244,11 +6122,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_40_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_40_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6276,10 +6155,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_40_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_02_ranges::regex_40_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6287,15 +6167,16 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_02_ranges::regex_40_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_02_ranges::regex_40_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_02_ranges::regex_40_matcher::to_string() -> std::string{return R"(ab{0,1}c)"; } + template [[nodiscard]] constexpr auto test_tests_02_ranges::regex_40_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_02_ranges::regex_40_matcher::to_string() -> std::string{return R"(ab{0,1}c)"; } -#line 251 "pure2-regex_02_ranges.cpp2" +#line 252 "pure2-regex_02_ranges.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_02_ranges()); } diff --git a/regression-tests/test-results/pure2-regex_03_wildcard.cpp b/regression-tests/test-results/pure2-regex_03_wildcard.cpp index 7fabdc2d83..81242ca0a8 100644 --- a/regression-tests/test-results/pure2-regex_03_wildcard.cpp +++ b/regression-tests/test-results/pure2-regex_03_wildcard.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_03_wildcard.cpp2" -#line 165 "pure2-regex_03_wildcard.cpp2" +#line 166 "pure2-regex_03_wildcard.cpp2" class test_tests_03_wildcard; @@ -18,47 +18,41 @@ class test_tests_03_wildcard; #line 1 "pure2-regex_03_wildcard.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_03_wildcard.cpp2" +#line 113 "pure2-regex_03_wildcard.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_03_wildcard.cpp2" +#line 125 "pure2-regex_03_wildcard.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_03_wildcard.cpp2" +#line 166 "pure2-regex_03_wildcard.cpp2" class test_tests_03_wildcard { -#line 186 "pure2-regex_03_wildcard.cpp2" +#line 187 "pure2-regex_03_wildcard.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -66,35 +60,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -102,35 +90,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_02 {}; public: class regex_03_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_03_matcher() = default; public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -138,35 +120,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_03 {}; public: class regex_04_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_04_matcher() = default; public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -174,35 +150,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_04 {}; public: class regex_05_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_05_matcher() = default; public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -210,35 +180,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_05 {}; public: class regex_06_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_06_matcher() = default; public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -246,35 +210,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_06 {}; public: class regex_07_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_06 {}; public: template class regex_07_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_07_matcher() = default; public: regex_07_matcher(regex_07_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -282,35 +240,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_07 {}; public: class regex_08_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_07 {}; public: template class regex_08_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_08_matcher() = default; public: regex_08_matcher(regex_08_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -318,35 +270,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_08 {}; public: class regex_09_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_08 {}; public: template class regex_09_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_09_matcher() = default; public: regex_09_matcher(regex_09_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -354,35 +300,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_09 {}; public: class regex_10_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_09 {}; public: template class regex_10_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_10_matcher() = default; public: regex_10_matcher(regex_10_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -390,35 +330,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_10 {}; public: class regex_11_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_10 {}; public: template class regex_11_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_11_matcher() = default; public: regex_11_matcher(regex_11_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -426,35 +360,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_11 {}; public: class regex_12_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_11 {}; public: template class regex_12_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_12_matcher() = default; public: regex_12_matcher(regex_12_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -462,35 +390,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_12 {}; public: class regex_13_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_12 {}; public: template class regex_13_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_13_matcher() = default; public: regex_13_matcher(regex_13_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -498,25 +420,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_13 {}; public: class regex_14_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_13 {}; public: template class regex_14_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_14_matcher() = default; public: regex_14_matcher(regex_14_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -524,25 +440,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_14 {}; public: class regex_15_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_14 {}; public: template class regex_15_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_15_matcher() = default; public: regex_15_matcher(regex_15_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -550,25 +460,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_15 {}; public: class regex_16_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_15 {}; public: template class regex_16_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_16_matcher() = default; public: regex_16_matcher(regex_16_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -576,35 +480,29 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_16 {}; public: class regex_17_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_16 {}; public: template class regex_17_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_17_matcher() = default; public: regex_17_matcher(regex_17_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -612,35 +510,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_17 {}; public: class regex_18_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_17 {}; public: template class regex_18_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_18_matcher() = default; public: regex_18_matcher(regex_18_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -648,35 +540,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_18 {}; public: class regex_19_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_18 {}; public: template class regex_19_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_19_matcher() = default; public: regex_19_matcher(regex_19_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -684,35 +570,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_19 {}; public: class regex_20_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_19 {}; public: template class regex_20_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_20_matcher() = default; public: regex_20_matcher(regex_20_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -720,13 +600,13 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_20 {}; + public: cpp2::regex::regular_expression> regex_20 {}; public: test_tests_03_wildcard() = default; public: test_tests_03_wildcard(test_tests_03_wildcard const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_03_wildcard const&) -> void = delete; -#line 210 "pure2-regex_03_wildcard.cpp2" +#line 211 "pure2-regex_03_wildcard.cpp2" }; auto main() -> int; @@ -830,6 +710,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -845,7 +726,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_03_wildcard.cpp2" +#line 113 "pure2-regex_03_wildcard.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -858,7 +739,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_03_wildcard.cpp2" +#line 125 "pure2-regex_03_wildcard.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -899,7 +780,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 186 "pure2-regex_03_wildcard.cpp2" +#line 187 "pure2-regex_03_wildcard.cpp2" auto test_tests_03_wildcard::run() const& -> void{ std::cout << "Running tests_03_wildcard:" << std::endl; test(regex_01, "01", R"(.{1})", "abbbbc", "y", R"($&)", "a"); @@ -928,8 +809,7 @@ template auto test(M const& regex, cpp2::impl::in id, c - - template [[nodiscard]] auto test_tests_03_wildcard::regex_01_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_01_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -944,11 +824,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -962,11 +843,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_01_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_01_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -980,10 +862,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -991,19 +874,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_01_matcher::to_string() -> std::string{return R"(.{1})"; } + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_01_matcher::to_string() -> std::string{return R"(.{1})"; } - - template [[nodiscard]] auto test_tests_03_wildcard::regex_02_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_02_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1018,11 +901,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1036,11 +920,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_02_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_02_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1054,10 +939,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1065,19 +951,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_02_matcher::to_string() -> std::string{return R"(.{1})"; } - + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_02_matcher::to_string() -> std::string{return R"(.{1})"; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_03_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_03_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1092,11 +978,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_03_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1110,11 +997,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_03_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_03_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1128,10 +1016,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_03_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1139,19 +1028,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_03_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_03_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_03_matcher::to_string() -> std::string{return R"(.{1})"; } - + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_03_matcher::to_string() -> std::string{return R"(.{1})"; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_04_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_04_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1166,11 +1055,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_04_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1184,11 +1074,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_04_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_04_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1202,10 +1093,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_04_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1213,19 +1105,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_04_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_04_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_04_matcher::to_string() -> std::string{return R"(.{3,4})"; } + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_04_matcher::to_string() -> std::string{return R"(.{3,4})"; } - - template [[nodiscard]] auto test_tests_03_wildcard::regex_05_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_05_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1240,11 +1132,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_05_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1258,11 +1151,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_05_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_05_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1276,10 +1170,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_05_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1287,19 +1182,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_05_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_05_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_05_matcher::to_string() -> std::string{return R"(.{3,4})"; } - + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_05_matcher::to_string() -> std::string{return R"(.{3,4})"; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_06_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_06_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1314,11 +1209,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_06_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1332,11 +1228,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_06_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_06_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1350,10 +1247,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_06_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1361,19 +1259,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_06_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_06_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_06_matcher::to_string() -> std::string{return R"(.{3,4})"; } + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_06_matcher::to_string() -> std::string{return R"(.{3,4})"; } - - template [[nodiscard]] auto test_tests_03_wildcard::regex_07_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_07_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1388,11 +1286,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_07_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_07_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1406,11 +1305,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_07_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_07_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1424,10 +1324,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_07_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_07_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1435,19 +1336,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_07_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_07_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_07_matcher::to_string() -> std::string{return R"(\N{1})"; } - + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_07_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_07_matcher::to_string() -> std::string{return R"(\N{1})"; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_08_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_08_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1462,11 +1363,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_08_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_08_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1480,11 +1382,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_08_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_08_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1498,10 +1401,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_08_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_08_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1509,19 +1413,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_08_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_08_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_08_matcher::to_string() -> std::string{return R"(\N{1})"; } - + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_08_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_08_matcher::to_string() -> std::string{return R"(\N{1})"; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_09_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_09_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1536,11 +1440,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_09_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_09_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1554,11 +1459,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_09_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_09_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1572,10 +1478,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_09_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_09_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1583,19 +1490,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_09_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_09_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_09_matcher::to_string() -> std::string{return R"(\N{1})"; } + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_09_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_09_matcher::to_string() -> std::string{return R"(\N{1})"; } - - template [[nodiscard]] auto test_tests_03_wildcard::regex_10_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_10_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1610,11 +1517,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_10_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_10_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1628,11 +1536,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_10_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_10_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1646,10 +1555,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_10_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_10_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1657,19 +1567,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_10_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_10_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_10_matcher::to_string() -> std::string{return R"(\N{3,4})"; } - + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_10_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_10_matcher::to_string() -> std::string{return R"(\N{3,4})"; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_11_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_11_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1684,11 +1594,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_11_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_11_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1702,11 +1613,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_11_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_11_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1720,10 +1632,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_11_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_11_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1731,19 +1644,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_11_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_11_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_11_matcher::to_string() -> std::string{return R"(\N{3,4})"; } + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_11_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_11_matcher::to_string() -> std::string{return R"(\N{3,4})"; } - - template [[nodiscard]] auto test_tests_03_wildcard::regex_12_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_12_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1758,11 +1671,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_12_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_12_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1776,11 +1690,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_12_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_12_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1794,10 +1709,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_12_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_12_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1805,19 +1721,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_12_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_12_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_12_matcher::to_string() -> std::string{return R"(\N{3,4})"; } - + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_12_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_12_matcher::to_string() -> std::string{return R"(\N{3,4})"; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_13_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_13_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1832,11 +1748,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_13_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_13_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1850,11 +1767,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_13_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_13_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1868,10 +1786,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_13_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_13_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1879,19 +1798,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_13_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_13_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_13_matcher::to_string() -> std::string{return R"(\N{3,4})"; } - + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_13_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_13_matcher::to_string() -> std::string{return R"(\N{3,4})"; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_14_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_14_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1934,10 +1853,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_14_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_14_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1945,19 +1865,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_14_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_14_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_14_matcher::to_string() -> std::string{return R"(a.c)"; } + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_14_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_14_matcher::to_string() -> std::string{return R"(a.c)"; } - - template [[nodiscard]] auto test_tests_03_wildcard::regex_15_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_15_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2000,10 +1920,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_15_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_15_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2011,19 +1932,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_15_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_15_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_15_matcher::to_string() -> std::string{return R"(a.c)"; } - + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_15_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_15_matcher::to_string() -> std::string{return R"(a.c)"; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_16_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_16_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2066,10 +1987,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_16_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_16_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2077,19 +1999,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_16_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_16_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_16_matcher::to_string() -> std::string{return R"(a\Nc)"; } + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_16_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_16_matcher::to_string() -> std::string{return R"(a\Nc)"; } - - template [[nodiscard]] auto test_tests_03_wildcard::regex_17_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_17_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2104,11 +2026,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_17_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_17_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2136,11 +2059,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_17_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_17_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2168,10 +2092,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_17_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_17_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2179,19 +2104,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_17_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_17_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_17_matcher::to_string() -> std::string{return R"(a.*c)"; } - + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_17_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_17_matcher::to_string() -> std::string{return R"(a.*c)"; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_18_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_18_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2206,11 +2131,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_18_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_18_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2238,11 +2164,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_18_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_18_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2270,10 +2197,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_18_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_18_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2281,19 +2209,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_18_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_18_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_18_matcher::to_string() -> std::string{return R"(a\N*c)"; } - + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_18_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_18_matcher::to_string() -> std::string{return R"(a\N*c)"; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_19_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_19_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2308,11 +2236,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_19_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_19_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2340,11 +2269,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_19_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_19_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2372,10 +2302,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_19_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_19_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2383,19 +2314,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_19_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_19_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_19_matcher::to_string() -> std::string{return R"(a.*c)"; } + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_19_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_19_matcher::to_string() -> std::string{return R"(a.*c)"; } - - template [[nodiscard]] auto test_tests_03_wildcard::regex_20_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_20_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2410,11 +2341,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_20_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_20_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2442,11 +2374,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_20_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_20_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2474,10 +2407,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_20_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_03_wildcard::regex_20_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2485,15 +2419,16 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_03_wildcard::regex_20_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_03_wildcard::regex_20_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_03_wildcard::regex_20_matcher::to_string() -> std::string{return R"(a\N*c)"; } + template [[nodiscard]] constexpr auto test_tests_03_wildcard::regex_20_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_03_wildcard::regex_20_matcher::to_string() -> std::string{return R"(a\N*c)"; } -#line 211 "pure2-regex_03_wildcard.cpp2" +#line 212 "pure2-regex_03_wildcard.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_03_wildcard()); } diff --git a/regression-tests/test-results/pure2-regex_04_start_end.cpp b/regression-tests/test-results/pure2-regex_04_start_end.cpp index 04aed896b3..b5a44d69c1 100644 --- a/regression-tests/test-results/pure2-regex_04_start_end.cpp +++ b/regression-tests/test-results/pure2-regex_04_start_end.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_04_start_end.cpp2" -#line 165 "pure2-regex_04_start_end.cpp2" +#line 166 "pure2-regex_04_start_end.cpp2" class test_tests_04_start_end; @@ -18,37 +18,31 @@ class test_tests_04_start_end; #line 1 "pure2-regex_04_start_end.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_04_start_end.cpp2" +#line 113 "pure2-regex_04_start_end.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_04_start_end.cpp2" +#line 125 "pure2-regex_04_start_end.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_04_start_end.cpp2" +#line 166 "pure2-regex_04_start_end.cpp2" class test_tests_04_start_end { -#line 175 "pure2-regex_04_start_end.cpp2" +#line 177 "pure2-regex_04_start_end.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -56,25 +50,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -82,25 +70,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_02 {}; public: class regex_03_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_03_matcher() = default; public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -108,25 +90,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_03 {}; public: class regex_04_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_04_matcher() = default; public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -134,25 +110,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_04 {}; public: class regex_05_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_05_matcher() = default; public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -160,25 +130,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_05 {}; public: class regex_06_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_06_matcher() = default; public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -186,25 +150,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_06 {}; public: class regex_07_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_06 {}; public: template class regex_07_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_07_matcher() = default; public: regex_07_matcher(regex_07_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -212,25 +170,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_07 {}; public: class regex_08_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_07 {}; public: template class regex_08_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_08_matcher() = default; public: regex_08_matcher(regex_08_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -238,25 +190,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_08 {}; public: class regex_09_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_08 {}; public: template class regex_09_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_09_matcher() = default; public: regex_09_matcher(regex_09_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -264,13 +210,43 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_09 {}; + public: cpp2::regex::regular_expression> regex_09 {}; public: template class regex_10_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_10_matcher() = default; + public: regex_10_matcher(regex_10_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_10_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_10 {}; public: test_tests_04_start_end() = default; public: test_tests_04_start_end(test_tests_04_start_end const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_04_start_end const&) -> void = delete; -#line 188 "pure2-regex_04_start_end.cpp2" +#line 191 "pure2-regex_04_start_end.cpp2" }; auto main() -> int; @@ -374,6 +350,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -389,7 +366,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_04_start_end.cpp2" +#line 113 "pure2-regex_04_start_end.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -402,7 +379,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_04_start_end.cpp2" +#line 125 "pure2-regex_04_start_end.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -443,7 +420,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 175 "pure2-regex_04_start_end.cpp2" +#line 177 "pure2-regex_04_start_end.cpp2" auto test_tests_04_start_end::run() const& -> void{ std::cout << "Running tests_04_start_end:" << std::endl; test(regex_01, "01", R"(^abc$)", "abc", "y", R"($&)", "abc"); @@ -455,14 +432,14 @@ template auto test(M const& regex, cpp2::impl::in id, c test(regex_07, "07", R"(^)", "abc", "y", R"($&)", ""); test(regex_08, "08", R"($)", "abc", "y", R"($&)", ""); test(regex_09, "09", R"($b)", "b", "n", R"(-)", "-"); + test(regex_10, "10", R"(\GX.*X)", "aaaXbX", "n", R"(-)", "-"); std::cout << std::endl; } - - template [[nodiscard]] auto test_tests_04_start_end::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_04_start_end::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -492,10 +469,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_04_start_end::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_04_start_end::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -503,19 +481,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_04_start_end::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_04_start_end::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_04_start_end::regex_01_matcher::to_string() -> std::string{return R"(^abc$)"; } + template [[nodiscard]] constexpr auto test_tests_04_start_end::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_04_start_end::regex_01_matcher::to_string() -> std::string{return R"(^abc$)"; } - - template [[nodiscard]] auto test_tests_04_start_end::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_04_start_end::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -545,10 +523,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_04_start_end::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_04_start_end::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -556,19 +535,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_04_start_end::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_04_start_end::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_04_start_end::regex_02_matcher::to_string() -> std::string{return R"(^abc$)"; } - + template [[nodiscard]] constexpr auto test_tests_04_start_end::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_04_start_end::regex_02_matcher::to_string() -> std::string{return R"(^abc$)"; } - template [[nodiscard]] auto test_tests_04_start_end::regex_03_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_04_start_end::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -597,10 +576,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_04_start_end::regex_03_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_04_start_end::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -608,19 +588,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_04_start_end::regex_03_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_04_start_end::regex_03_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_04_start_end::regex_03_matcher::to_string() -> std::string{return R"(^abc)"; } - + template [[nodiscard]] constexpr auto test_tests_04_start_end::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_04_start_end::regex_03_matcher::to_string() -> std::string{return R"(^abc)"; } - template [[nodiscard]] auto test_tests_04_start_end::regex_04_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_04_start_end::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -650,10 +630,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_04_start_end::regex_04_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_04_start_end::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -661,19 +642,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_04_start_end::regex_04_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_04_start_end::regex_04_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_04_start_end::regex_04_matcher::to_string() -> std::string{return R"(^abc$)"; } + template [[nodiscard]] constexpr auto test_tests_04_start_end::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_04_start_end::regex_04_matcher::to_string() -> std::string{return R"(^abc$)"; } - - template [[nodiscard]] auto test_tests_04_start_end::regex_05_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_04_start_end::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -702,10 +683,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_04_start_end::regex_05_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_04_start_end::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -713,19 +695,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_04_start_end::regex_05_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_04_start_end::regex_05_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_04_start_end::regex_05_matcher::to_string() -> std::string{return R"(abc$)"; } - + template [[nodiscard]] constexpr auto test_tests_04_start_end::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_04_start_end::regex_05_matcher::to_string() -> std::string{return R"(abc$)"; } - template [[nodiscard]] auto test_tests_04_start_end::regex_06_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_04_start_end::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -754,10 +736,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_04_start_end::regex_06_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_04_start_end::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -765,19 +748,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_04_start_end::regex_06_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_04_start_end::regex_06_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_04_start_end::regex_06_matcher::to_string() -> std::string{return R"(abc$)"; } + template [[nodiscard]] constexpr auto test_tests_04_start_end::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_04_start_end::regex_06_matcher::to_string() -> std::string{return R"(abc$)"; } - - template [[nodiscard]] auto test_tests_04_start_end::regex_07_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_04_start_end::regex_07_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -792,10 +775,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_04_start_end::regex_07_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_04_start_end::regex_07_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -803,19 +787,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_04_start_end::regex_07_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_04_start_end::regex_07_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_04_start_end::regex_07_matcher::to_string() -> std::string{return R"(^)"; } - + template [[nodiscard]] constexpr auto test_tests_04_start_end::regex_07_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_04_start_end::regex_07_matcher::to_string() -> std::string{return R"(^)"; } - template [[nodiscard]] auto test_tests_04_start_end::regex_08_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_04_start_end::regex_08_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -830,10 +814,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_04_start_end::regex_08_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_04_start_end::regex_08_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -841,19 +826,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_04_start_end::regex_08_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_04_start_end::regex_08_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_04_start_end::regex_08_matcher::to_string() -> std::string{return R"($)"; } + template [[nodiscard]] constexpr auto test_tests_04_start_end::regex_08_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_04_start_end::regex_08_matcher::to_string() -> std::string{return R"($)"; } - - template [[nodiscard]] auto test_tests_04_start_end::regex_09_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_04_start_end::regex_09_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -882,10 +867,116 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_04_start_end::regex_09_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_04_start_end::regex_09_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_04_start_end::regex_09_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_04_start_end::regex_09_matcher::to_string() -> std::string{return R"($b)"; } + + + + + + template template [[nodiscard]] auto test_tests_04_start_end::regex_10_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_04_start_end::regex_10_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"X"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_04_start_end::regex_10_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"X"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_04_start_end::regex_09_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_04_start_end::regex_10_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -893,15 +984,16 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_04_start_end::regex_09_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_04_start_end::regex_10_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_04_start_end::regex_09_matcher::to_string() -> std::string{return R"($b)"; } + template [[nodiscard]] constexpr auto test_tests_04_start_end::regex_10_matcher::is_start_match() -> bool { return true; } +template [[nodiscard]] auto test_tests_04_start_end::regex_10_matcher::to_string() -> std::string{return R"(\GX.*X)"; } -#line 189 "pure2-regex_04_start_end.cpp2" +#line 192 "pure2-regex_04_start_end.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_04_start_end()); } diff --git a/regression-tests/test-results/pure2-regex_05_classes.cpp b/regression-tests/test-results/pure2-regex_05_classes.cpp index 68a660bb56..9edb7b49b4 100644 --- a/regression-tests/test-results/pure2-regex_05_classes.cpp +++ b/regression-tests/test-results/pure2-regex_05_classes.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_05_classes.cpp2" -#line 165 "pure2-regex_05_classes.cpp2" +#line 166 "pure2-regex_05_classes.cpp2" class test_tests_05_classes; @@ -18,37 +18,31 @@ class test_tests_05_classes; #line 1 "pure2-regex_05_classes.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_05_classes.cpp2" +#line 113 "pure2-regex_05_classes.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_05_classes.cpp2" +#line 125 "pure2-regex_05_classes.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_05_classes.cpp2" +#line 166 "pure2-regex_05_classes.cpp2" class test_tests_05_classes { -#line 185 "pure2-regex_05_classes.cpp2" +#line 186 "pure2-regex_05_classes.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -56,25 +50,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -82,25 +70,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_02 {}; public: class regex_03_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_03_matcher() = default; public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -108,25 +90,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_03 {}; public: class regex_04_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_04_matcher() = default; public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -134,25 +110,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_04 {}; public: class regex_05_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_05_matcher() = default; public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -160,25 +130,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_05 {}; public: class regex_06_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_06_matcher() = default; public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -186,25 +150,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_06 {}; public: class regex_07_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_06 {}; public: template class regex_07_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_07_matcher() = default; public: regex_07_matcher(regex_07_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -212,25 +170,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_07 {}; public: class regex_08_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_07 {}; public: template class regex_08_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_08_matcher() = default; public: regex_08_matcher(regex_08_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -238,25 +190,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_08 {}; public: class regex_09_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_08 {}; public: template class regex_09_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_09_matcher() = default; public: regex_09_matcher(regex_09_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -264,25 +210,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_09 {}; public: class regex_10_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_09 {}; public: template class regex_10_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_10_matcher() = default; public: regex_10_matcher(regex_10_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -290,25 +230,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_10 {}; public: class regex_11_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_10 {}; public: template class regex_11_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_11_matcher() = default; public: regex_11_matcher(regex_11_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -316,25 +250,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_11 {}; public: class regex_12_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_11 {}; public: template class regex_12_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_12_matcher() = default; public: regex_12_matcher(regex_12_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -342,25 +270,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_12 {}; public: class regex_13_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_12 {}; public: template class regex_13_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_13_matcher() = default; public: regex_13_matcher(regex_13_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -368,25 +290,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_13 {}; public: class regex_14_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_13 {}; public: template class regex_14_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_14_matcher() = default; public: regex_14_matcher(regex_14_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -394,25 +310,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_14 {}; public: class regex_15_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_14 {}; public: template class regex_15_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_15_matcher() = default; public: regex_15_matcher(regex_15_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -420,25 +330,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_15 {}; public: class regex_16_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_15 {}; public: template class regex_16_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_16_matcher() = default; public: regex_16_matcher(regex_16_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -446,25 +350,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_16 {}; public: class regex_17_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_16 {}; public: template class regex_17_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_17_matcher() = default; public: regex_17_matcher(regex_17_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -472,25 +370,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_17 {}; public: class regex_18_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_17 {}; public: template class regex_18_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_18_matcher() = default; public: regex_18_matcher(regex_18_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -498,25 +390,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_18 {}; public: class regex_19_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_18 {}; public: template class regex_19_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_19_matcher() = default; public: regex_19_matcher(regex_19_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -524,13 +410,13 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_19 {}; + public: cpp2::regex::regular_expression> regex_19 {}; public: test_tests_05_classes() = default; public: test_tests_05_classes(test_tests_05_classes const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_05_classes const&) -> void = delete; -#line 208 "pure2-regex_05_classes.cpp2" +#line 209 "pure2-regex_05_classes.cpp2" }; auto main() -> int; @@ -634,6 +520,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -649,7 +536,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_05_classes.cpp2" +#line 113 "pure2-regex_05_classes.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -662,7 +549,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_05_classes.cpp2" +#line 125 "pure2-regex_05_classes.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -703,7 +590,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 185 "pure2-regex_05_classes.cpp2" +#line 186 "pure2-regex_05_classes.cpp2" auto test_tests_05_classes::run() const& -> void{ std::cout << "Running tests_05_classes:" << std::endl; test(regex_01, "01", R"(a[bc]d)", "abc", "n", R"(-)", "-"); @@ -731,8 +618,7 @@ template auto test(M const& regex, cpp2::impl::in id, c - - template [[nodiscard]] auto test_tests_05_classes::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -775,10 +661,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -786,19 +673,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_01_matcher::to_string() -> std::string{return R"(a[bc]d)"; } + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_01_matcher::to_string() -> std::string{return R"(a[bc]d)"; } - - template [[nodiscard]] auto test_tests_05_classes::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -841,10 +728,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -852,19 +740,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_02_matcher::to_string() -> std::string{return R"(a[bc]d)"; } - + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_02_matcher::to_string() -> std::string{return R"(a[bc]d)"; } - template [[nodiscard]] auto test_tests_05_classes::regex_03_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -907,10 +795,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_03_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -918,19 +807,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_03_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_03_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_03_matcher::to_string() -> std::string{return R"(a[b]d)"; } - + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_03_matcher::to_string() -> std::string{return R"(a[b]d)"; } - template [[nodiscard]] auto test_tests_05_classes::regex_04_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -947,10 +836,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_04_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -958,19 +848,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_04_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_04_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_04_matcher::to_string() -> std::string{return R"([a][b][d])"; } + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_04_matcher::to_string() -> std::string{return R"([a][b][d])"; } - - template [[nodiscard]] auto test_tests_05_classes::regex_05_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -987,10 +877,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_05_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -998,19 +889,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_05_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_05_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_05_matcher::to_string() -> std::string{return R"(.[b].)"; } - + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_05_matcher::to_string() -> std::string{return R"(.[b].)"; } - template [[nodiscard]] auto test_tests_05_classes::regex_06_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1027,10 +918,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_06_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1038,19 +930,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_06_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_06_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_06_matcher::to_string() -> std::string{return R"(.[b].)"; } + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_06_matcher::to_string() -> std::string{return R"(.[b].)"; } - - template [[nodiscard]] auto test_tests_05_classes::regex_07_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_07_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1093,10 +985,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_07_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_07_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1104,19 +997,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_07_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_07_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_07_matcher::to_string() -> std::string{return R"(a[b-d]e)"; } - + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_07_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_07_matcher::to_string() -> std::string{return R"(a[b-d]e)"; } - template [[nodiscard]] auto test_tests_05_classes::regex_08_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_08_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1159,10 +1052,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_08_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_08_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1170,19 +1064,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_08_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_08_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_08_matcher::to_string() -> std::string{return R"(a[b-d]e)"; } - + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_08_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_08_matcher::to_string() -> std::string{return R"(a[b-d]e)"; } - template [[nodiscard]] auto test_tests_05_classes::regex_09_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_09_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1211,10 +1105,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_09_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_09_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1222,19 +1117,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_09_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_09_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_09_matcher::to_string() -> std::string{return R"(a[b-d])"; } + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_09_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_09_matcher::to_string() -> std::string{return R"(a[b-d])"; } - - template [[nodiscard]] auto test_tests_05_classes::regex_10_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_10_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1263,10 +1158,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_10_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_10_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1274,19 +1170,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_10_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_10_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_10_matcher::to_string() -> std::string{return R"(a[-b])"; } - + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_10_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_10_matcher::to_string() -> std::string{return R"(a[-b])"; } - template [[nodiscard]] auto test_tests_05_classes::regex_11_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_11_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1315,10 +1211,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_11_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_11_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1326,19 +1223,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_11_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_11_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_11_matcher::to_string() -> std::string{return R"(a[b-])"; } + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_11_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_11_matcher::to_string() -> std::string{return R"(a[b-])"; } - - template [[nodiscard]] auto test_tests_05_classes::regex_12_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_12_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1366,10 +1263,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_12_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_12_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1377,19 +1275,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_12_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_12_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_12_matcher::to_string() -> std::string{return R"(a])"; } - + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_12_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_12_matcher::to_string() -> std::string{return R"(a])"; } - template [[nodiscard]] auto test_tests_05_classes::regex_13_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_13_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1432,10 +1330,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_13_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_13_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1443,19 +1342,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_13_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_13_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_13_matcher::to_string() -> std::string{return R"(a[]]b)"; } - + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_13_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_13_matcher::to_string() -> std::string{return R"(a[]]b)"; } - template [[nodiscard]] auto test_tests_05_classes::regex_14_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_14_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1498,10 +1397,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_14_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_14_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1509,19 +1409,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_14_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_14_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_14_matcher::to_string() -> std::string{return R"(a[^bc]d)"; } + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_14_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_14_matcher::to_string() -> std::string{return R"(a[^bc]d)"; } - - template [[nodiscard]] auto test_tests_05_classes::regex_15_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_15_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1564,10 +1464,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_15_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_15_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1575,19 +1476,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_15_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_15_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_15_matcher::to_string() -> std::string{return R"(a[^bc]d)"; } - + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_15_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_15_matcher::to_string() -> std::string{return R"(a[^bc]d)"; } - template [[nodiscard]] auto test_tests_05_classes::regex_16_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_16_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1630,10 +1531,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_16_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_16_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1641,19 +1543,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_16_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_16_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_16_matcher::to_string() -> std::string{return R"(a[^-b]c)"; } + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_16_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_16_matcher::to_string() -> std::string{return R"(a[^-b]c)"; } - - template [[nodiscard]] auto test_tests_05_classes::regex_17_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_17_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1696,10 +1598,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_17_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_17_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1707,19 +1610,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_17_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_17_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_17_matcher::to_string() -> std::string{return R"(a[^-b]c)"; } - + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_17_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_17_matcher::to_string() -> std::string{return R"(a[^-b]c)"; } - template [[nodiscard]] auto test_tests_05_classes::regex_18_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_18_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1762,10 +1665,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_18_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_18_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1773,19 +1677,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_18_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_18_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_18_matcher::to_string() -> std::string{return R"(a[^]b]c)"; } + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_18_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_18_matcher::to_string() -> std::string{return R"(a[^]b]c)"; } - - template [[nodiscard]] auto test_tests_05_classes::regex_19_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_19_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1828,10 +1732,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_19_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_05_classes::regex_19_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1839,15 +1744,16 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_05_classes::regex_19_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_05_classes::regex_19_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_05_classes::regex_19_matcher::to_string() -> std::string{return R"(a[^]b]c)"; } + template [[nodiscard]] constexpr auto test_tests_05_classes::regex_19_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_05_classes::regex_19_matcher::to_string() -> std::string{return R"(a[^]b]c)"; } -#line 209 "pure2-regex_05_classes.cpp2" +#line 210 "pure2-regex_05_classes.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_05_classes()); } diff --git a/regression-tests/test-results/pure2-regex_06_boundaries.cpp b/regression-tests/test-results/pure2-regex_06_boundaries.cpp index db9bf5e83f..d3de466a09 100644 --- a/regression-tests/test-results/pure2-regex_06_boundaries.cpp +++ b/regression-tests/test-results/pure2-regex_06_boundaries.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_06_boundaries.cpp2" -#line 165 "pure2-regex_06_boundaries.cpp2" +#line 166 "pure2-regex_06_boundaries.cpp2" class test_tests_06_boundaries; @@ -18,37 +18,31 @@ class test_tests_06_boundaries; #line 1 "pure2-regex_06_boundaries.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_06_boundaries.cpp2" +#line 113 "pure2-regex_06_boundaries.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_06_boundaries.cpp2" +#line 125 "pure2-regex_06_boundaries.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_06_boundaries.cpp2" +#line 166 "pure2-regex_06_boundaries.cpp2" class test_tests_06_boundaries { -#line 183 "pure2-regex_06_boundaries.cpp2" +#line 184 "pure2-regex_06_boundaries.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -56,25 +50,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -82,25 +70,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_02 {}; public: class regex_03_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_03_matcher() = default; public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -108,25 +90,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_03 {}; public: class regex_04_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_04_matcher() = default; public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -134,25 +110,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_04 {}; public: class regex_05_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_05_matcher() = default; public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -160,25 +130,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_05 {}; public: class regex_06_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_06_matcher() = default; public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -186,25 +150,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_06 {}; public: class regex_07_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_06 {}; public: template class regex_07_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_07_matcher() = default; public: regex_07_matcher(regex_07_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -212,25 +170,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_07 {}; public: class regex_08_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_07 {}; public: template class regex_08_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_08_matcher() = default; public: regex_08_matcher(regex_08_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -238,25 +190,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_08 {}; public: class regex_09_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_08 {}; public: template class regex_09_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_09_matcher() = default; public: regex_09_matcher(regex_09_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -264,25 +210,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_09 {}; public: class regex_10_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_09 {}; public: template class regex_10_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_10_matcher() = default; public: regex_10_matcher(regex_10_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -290,25 +230,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_10 {}; public: class regex_11_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_10 {}; public: template class regex_11_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_11_matcher() = default; public: regex_11_matcher(regex_11_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -316,25 +250,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_11 {}; public: class regex_12_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_11 {}; public: template class regex_12_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_12_matcher() = default; public: regex_12_matcher(regex_12_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -342,25 +270,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_12 {}; public: class regex_13_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_12 {}; public: template class regex_13_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_13_matcher() = default; public: regex_13_matcher(regex_13_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -368,25 +290,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_13 {}; public: class regex_14_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_13 {}; public: template class regex_14_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_14_matcher() = default; public: regex_14_matcher(regex_14_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -394,25 +310,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_14 {}; public: class regex_15_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_14 {}; public: template class regex_15_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_15_matcher() = default; public: regex_15_matcher(regex_15_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -420,25 +330,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_15 {}; public: class regex_16_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_15 {}; public: template class regex_16_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_16_matcher() = default; public: regex_16_matcher(regex_16_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -446,25 +350,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_16 {}; public: class regex_17_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_16 {}; public: template class regex_17_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_17_matcher() = default; public: regex_17_matcher(regex_17_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -472,13 +370,13 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_17 {}; + public: cpp2::regex::regular_expression> regex_17 {}; public: test_tests_06_boundaries() = default; public: test_tests_06_boundaries(test_tests_06_boundaries const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_06_boundaries const&) -> void = delete; -#line 204 "pure2-regex_06_boundaries.cpp2" +#line 205 "pure2-regex_06_boundaries.cpp2" }; auto main() -> int; @@ -582,6 +480,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -597,7 +496,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_06_boundaries.cpp2" +#line 113 "pure2-regex_06_boundaries.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -610,7 +509,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_06_boundaries.cpp2" +#line 125 "pure2-regex_06_boundaries.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -651,7 +550,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 183 "pure2-regex_06_boundaries.cpp2" +#line 184 "pure2-regex_06_boundaries.cpp2" auto test_tests_06_boundaries::run() const& -> void{ std::cout << "Running tests_06_boundaries:" << std::endl; test(regex_01, "01", R"(\ba\b)", "a-", "y", R"(-)", "-"); @@ -677,8 +576,7 @@ template auto test(M const& regex, cpp2::impl::in id, c - - template [[nodiscard]] auto test_tests_06_boundaries::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -708,10 +606,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -719,19 +618,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_06_boundaries::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_06_boundaries::regex_01_matcher::to_string() -> std::string{return R"(\ba\b)"; } + template [[nodiscard]] constexpr auto test_tests_06_boundaries::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_06_boundaries::regex_01_matcher::to_string() -> std::string{return R"(\ba\b)"; } - - template [[nodiscard]] auto test_tests_06_boundaries::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -761,10 +660,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -772,19 +672,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_06_boundaries::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_06_boundaries::regex_02_matcher::to_string() -> std::string{return R"(\ba\b)"; } - + template [[nodiscard]] constexpr auto test_tests_06_boundaries::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_06_boundaries::regex_02_matcher::to_string() -> std::string{return R"(\ba\b)"; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_03_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -814,10 +714,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_03_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -825,19 +726,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_03_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_06_boundaries::regex_03_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_06_boundaries::regex_03_matcher::to_string() -> std::string{return R"(\ba\b)"; } - + template [[nodiscard]] constexpr auto test_tests_06_boundaries::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_06_boundaries::regex_03_matcher::to_string() -> std::string{return R"(\ba\b)"; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_04_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -867,10 +768,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_04_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -878,19 +780,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_04_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_06_boundaries::regex_04_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_06_boundaries::regex_04_matcher::to_string() -> std::string{return R"(\by\b)"; } + template [[nodiscard]] constexpr auto test_tests_06_boundaries::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_06_boundaries::regex_04_matcher::to_string() -> std::string{return R"(\by\b)"; } - - template [[nodiscard]] auto test_tests_06_boundaries::regex_05_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -920,10 +822,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_05_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -931,19 +834,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_05_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_06_boundaries::regex_05_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_06_boundaries::regex_05_matcher::to_string() -> std::string{return R"(\by\b)"; } - + template [[nodiscard]] constexpr auto test_tests_06_boundaries::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_06_boundaries::regex_05_matcher::to_string() -> std::string{return R"(\by\b)"; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_06_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -973,10 +876,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_06_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -984,19 +888,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_06_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_06_boundaries::regex_06_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_06_boundaries::regex_06_matcher::to_string() -> std::string{return R"(\by\b)"; } + template [[nodiscard]] constexpr auto test_tests_06_boundaries::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_06_boundaries::regex_06_matcher::to_string() -> std::string{return R"(\by\b)"; } - - template [[nodiscard]] auto test_tests_06_boundaries::regex_07_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_07_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1026,10 +930,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_07_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_07_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1037,19 +942,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_07_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_06_boundaries::regex_07_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_06_boundaries::regex_07_matcher::to_string() -> std::string{return R"(\Ba\B)"; } - + template [[nodiscard]] constexpr auto test_tests_06_boundaries::regex_07_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_06_boundaries::regex_07_matcher::to_string() -> std::string{return R"(\Ba\B)"; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_08_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_08_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1079,10 +984,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_08_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_08_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1090,19 +996,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_08_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_06_boundaries::regex_08_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_06_boundaries::regex_08_matcher::to_string() -> std::string{return R"(\Ba\B)"; } + template [[nodiscard]] constexpr auto test_tests_06_boundaries::regex_08_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_06_boundaries::regex_08_matcher::to_string() -> std::string{return R"(\Ba\B)"; } - - template [[nodiscard]] auto test_tests_06_boundaries::regex_09_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_09_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1132,10 +1038,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_09_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_09_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1143,19 +1050,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_09_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_06_boundaries::regex_09_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_06_boundaries::regex_09_matcher::to_string() -> std::string{return R"(\Ba\B)"; } - + template [[nodiscard]] constexpr auto test_tests_06_boundaries::regex_09_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_06_boundaries::regex_09_matcher::to_string() -> std::string{return R"(\Ba\B)"; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_10_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_10_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1185,10 +1092,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_10_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_10_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1196,19 +1104,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_10_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_06_boundaries::regex_10_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_06_boundaries::regex_10_matcher::to_string() -> std::string{return R"(\By\b)"; } + template [[nodiscard]] constexpr auto test_tests_06_boundaries::regex_10_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_06_boundaries::regex_10_matcher::to_string() -> std::string{return R"(\By\b)"; } - - template [[nodiscard]] auto test_tests_06_boundaries::regex_11_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_11_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1238,10 +1146,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_11_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_11_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1249,19 +1158,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_11_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_06_boundaries::regex_11_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_06_boundaries::regex_11_matcher::to_string() -> std::string{return R"(\By\b)"; } - + template [[nodiscard]] constexpr auto test_tests_06_boundaries::regex_11_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_06_boundaries::regex_11_matcher::to_string() -> std::string{return R"(\By\b)"; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_12_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_12_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1291,10 +1200,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_12_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_12_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1302,19 +1212,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_12_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_06_boundaries::regex_12_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_06_boundaries::regex_12_matcher::to_string() -> std::string{return R"(\By\b)"; } + template [[nodiscard]] constexpr auto test_tests_06_boundaries::regex_12_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_06_boundaries::regex_12_matcher::to_string() -> std::string{return R"(\By\b)"; } - - template [[nodiscard]] auto test_tests_06_boundaries::regex_13_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_13_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1344,10 +1254,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_13_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_13_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1355,19 +1266,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_13_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_06_boundaries::regex_13_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_06_boundaries::regex_13_matcher::to_string() -> std::string{return R"(\By\b)"; } - + template [[nodiscard]] constexpr auto test_tests_06_boundaries::regex_13_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_06_boundaries::regex_13_matcher::to_string() -> std::string{return R"(\By\b)"; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_14_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_14_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1397,10 +1308,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_14_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_14_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1408,19 +1320,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_14_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_06_boundaries::regex_14_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_06_boundaries::regex_14_matcher::to_string() -> std::string{return R"(\by\B)"; } + template [[nodiscard]] constexpr auto test_tests_06_boundaries::regex_14_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_06_boundaries::regex_14_matcher::to_string() -> std::string{return R"(\by\B)"; } - - template [[nodiscard]] auto test_tests_06_boundaries::regex_15_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_15_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1450,10 +1362,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_15_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_15_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1461,19 +1374,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_15_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_06_boundaries::regex_15_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_06_boundaries::regex_15_matcher::to_string() -> std::string{return R"(\By\B)"; } - + template [[nodiscard]] constexpr auto test_tests_06_boundaries::regex_15_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_06_boundaries::regex_15_matcher::to_string() -> std::string{return R"(\By\B)"; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_16_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_16_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1488,10 +1401,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_16_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_16_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1499,19 +1413,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_16_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_06_boundaries::regex_16_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_06_boundaries::regex_16_matcher::to_string() -> std::string{return R"(\b)"; } + template [[nodiscard]] constexpr auto test_tests_06_boundaries::regex_16_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_06_boundaries::regex_16_matcher::to_string() -> std::string{return R"(\b)"; } - - template [[nodiscard]] auto test_tests_06_boundaries::regex_17_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_17_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1526,10 +1440,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_17_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_06_boundaries::regex_17_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1537,15 +1452,16 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_06_boundaries::regex_17_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_06_boundaries::regex_17_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_06_boundaries::regex_17_matcher::to_string() -> std::string{return R"(\B)"; } + template [[nodiscard]] constexpr auto test_tests_06_boundaries::regex_17_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_06_boundaries::regex_17_matcher::to_string() -> std::string{return R"(\B)"; } -#line 205 "pure2-regex_06_boundaries.cpp2" +#line 206 "pure2-regex_06_boundaries.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_06_boundaries()); } diff --git a/regression-tests/test-results/pure2-regex_07_short_classes.cpp b/regression-tests/test-results/pure2-regex_07_short_classes.cpp index 82c9fe36fc..5cc698ed3e 100644 --- a/regression-tests/test-results/pure2-regex_07_short_classes.cpp +++ b/regression-tests/test-results/pure2-regex_07_short_classes.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_07_short_classes.cpp2" -#line 165 "pure2-regex_07_short_classes.cpp2" +#line 166 "pure2-regex_07_short_classes.cpp2" class test_tests_07_short_classes; @@ -18,37 +18,31 @@ class test_tests_07_short_classes; #line 1 "pure2-regex_07_short_classes.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_07_short_classes.cpp2" +#line 113 "pure2-regex_07_short_classes.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_07_short_classes.cpp2" +#line 125 "pure2-regex_07_short_classes.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_07_short_classes.cpp2" +#line 166 "pure2-regex_07_short_classes.cpp2" class test_tests_07_short_classes { -#line 190 "pure2-regex_07_short_classes.cpp2" +#line 191 "pure2-regex_07_short_classes.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -56,25 +50,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -82,25 +70,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_02 {}; public: class regex_03_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_03_matcher() = default; public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -108,25 +90,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_03 {}; public: class regex_04_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_04_matcher() = default; public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -134,25 +110,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_04 {}; public: class regex_05_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_05_matcher() = default; public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -160,25 +130,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_05 {}; public: class regex_06_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_06_matcher() = default; public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -186,25 +150,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_06 {}; public: class regex_07_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_06 {}; public: template class regex_07_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_07_matcher() = default; public: regex_07_matcher(regex_07_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -212,25 +170,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_07 {}; public: class regex_08_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_07 {}; public: template class regex_08_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_08_matcher() = default; public: regex_08_matcher(regex_08_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -238,25 +190,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_08 {}; public: class regex_09_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_08 {}; public: template class regex_09_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_09_matcher() = default; public: regex_09_matcher(regex_09_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -264,25 +210,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_09 {}; public: class regex_10_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_09 {}; public: template class regex_10_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_10_matcher() = default; public: regex_10_matcher(regex_10_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -290,25 +230,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_10 {}; public: class regex_11_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_10 {}; public: template class regex_11_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_11_matcher() = default; public: regex_11_matcher(regex_11_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -316,25 +250,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_11 {}; public: class regex_12_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_11 {}; public: template class regex_12_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_12_matcher() = default; public: regex_12_matcher(regex_12_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -342,25 +270,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_12 {}; public: class regex_13_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_12 {}; public: template class regex_13_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_13_matcher() = default; public: regex_13_matcher(regex_13_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -368,25 +290,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_13 {}; public: class regex_14_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_13 {}; public: template class regex_14_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_14_matcher() = default; public: regex_14_matcher(regex_14_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -394,25 +310,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_14 {}; public: class regex_15_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_14 {}; public: template class regex_15_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_15_matcher() = default; public: regex_15_matcher(regex_15_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -420,25 +330,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_15 {}; public: class regex_16_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_15 {}; public: template class regex_16_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_16_matcher() = default; public: regex_16_matcher(regex_16_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -446,25 +350,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_16 {}; public: class regex_17_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_16 {}; public: template class regex_17_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_17_matcher() = default; public: regex_17_matcher(regex_17_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -472,25 +370,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_17 {}; public: class regex_18_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_17 {}; public: template class regex_18_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_18_matcher() = default; public: regex_18_matcher(regex_18_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -498,25 +390,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_18 {}; public: class regex_19_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_18 {}; public: template class regex_19_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_19_matcher() = default; public: regex_19_matcher(regex_19_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -524,25 +410,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_19 {}; public: class regex_20_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_19 {}; public: template class regex_20_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_20_matcher() = default; public: regex_20_matcher(regex_20_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -550,25 +430,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_20 {}; public: class regex_21_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_20 {}; public: template class regex_21_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_21_matcher() = default; public: regex_21_matcher(regex_21_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -576,25 +450,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_21 {}; public: class regex_22_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_21 {}; public: template class regex_22_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_22_matcher() = default; public: regex_22_matcher(regex_22_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -602,25 +470,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_22 {}; public: class regex_23_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_22 {}; public: template class regex_23_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_23_matcher() = default; public: regex_23_matcher(regex_23_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -628,25 +490,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_23 {}; public: class regex_24_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_23 {}; public: template class regex_24_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_24_matcher() = default; public: regex_24_matcher(regex_24_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -654,13 +510,13 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_24 {}; + public: cpp2::regex::regular_expression> regex_24 {}; public: test_tests_07_short_classes() = default; public: test_tests_07_short_classes(test_tests_07_short_classes const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_07_short_classes const&) -> void = delete; -#line 218 "pure2-regex_07_short_classes.cpp2" +#line 219 "pure2-regex_07_short_classes.cpp2" }; auto main() -> int; @@ -764,6 +620,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -779,7 +636,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_07_short_classes.cpp2" +#line 113 "pure2-regex_07_short_classes.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -792,7 +649,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_07_short_classes.cpp2" +#line 125 "pure2-regex_07_short_classes.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -833,7 +690,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 190 "pure2-regex_07_short_classes.cpp2" +#line 191 "pure2-regex_07_short_classes.cpp2" auto test_tests_07_short_classes::run() const& -> void{ std::cout << "Running tests_07_short_classes:" << std::endl; test(regex_01, "01", R"(\w)", "a", "y", R"(-)", "-"); @@ -866,8 +723,7 @@ template auto test(M const& regex, cpp2::impl::in id, c - - template [[nodiscard]] auto test_tests_07_short_classes::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -882,10 +738,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -893,19 +750,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_01_matcher::to_string() -> std::string{return R"(\w)"; } + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_01_matcher::to_string() -> std::string{return R"(\w)"; } - - template [[nodiscard]] auto test_tests_07_short_classes::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -920,10 +777,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -931,19 +789,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_02_matcher::to_string() -> std::string{return R"(\w)"; } - + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_02_matcher::to_string() -> std::string{return R"(\w)"; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_03_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -958,10 +816,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_03_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -969,19 +828,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_03_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_03_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_03_matcher::to_string() -> std::string{return R"(\W)"; } - + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_03_matcher::to_string() -> std::string{return R"(\W)"; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_04_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -996,10 +855,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_04_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1007,19 +867,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_04_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_04_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_04_matcher::to_string() -> std::string{return R"(\W)"; } + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_04_matcher::to_string() -> std::string{return R"(\W)"; } - - template [[nodiscard]] auto test_tests_07_short_classes::regex_05_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1062,10 +922,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_05_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1073,19 +934,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_05_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_05_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_05_matcher::to_string() -> std::string{return R"(a\sb)"; } - + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_05_matcher::to_string() -> std::string{return R"(a\sb)"; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_06_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1128,10 +989,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_06_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1139,19 +1001,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_06_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_06_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_06_matcher::to_string() -> std::string{return R"(a\sb)"; } - + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_06_matcher::to_string() -> std::string{return R"(a\sb)"; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_07_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_07_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1194,10 +1056,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_07_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_07_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1205,19 +1068,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_07_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_07_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_07_matcher::to_string() -> std::string{return R"(a\Sb)"; } + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_07_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_07_matcher::to_string() -> std::string{return R"(a\Sb)"; } - - template [[nodiscard]] auto test_tests_07_short_classes::regex_08_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_08_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1260,10 +1123,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_08_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_08_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1271,19 +1135,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_08_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_08_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_08_matcher::to_string() -> std::string{return R"(a\Sb)"; } - + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_08_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_08_matcher::to_string() -> std::string{return R"(a\Sb)"; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_09_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_09_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1298,10 +1162,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_09_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_09_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1309,19 +1174,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_09_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_09_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_09_matcher::to_string() -> std::string{return R"(\d)"; } - + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_09_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_09_matcher::to_string() -> std::string{return R"(\d)"; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_10_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_10_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1336,10 +1201,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_10_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_10_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1347,19 +1213,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_10_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_10_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_10_matcher::to_string() -> std::string{return R"(\d)"; } + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_10_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_10_matcher::to_string() -> std::string{return R"(\d)"; } - - template [[nodiscard]] auto test_tests_07_short_classes::regex_11_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_11_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1374,10 +1240,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_11_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_11_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1385,19 +1252,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_11_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_11_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_11_matcher::to_string() -> std::string{return R"(\D)"; } - + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_11_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_11_matcher::to_string() -> std::string{return R"(\D)"; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_12_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_12_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1412,10 +1279,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_12_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_12_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1423,19 +1291,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_12_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_12_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_12_matcher::to_string() -> std::string{return R"(\D)"; } - + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_12_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_12_matcher::to_string() -> std::string{return R"(\D)"; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_13_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_13_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1450,10 +1318,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_13_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_13_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1461,19 +1330,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_13_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_13_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_13_matcher::to_string() -> std::string{return R"([\w])"; } + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_13_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_13_matcher::to_string() -> std::string{return R"([\w])"; } - - template [[nodiscard]] auto test_tests_07_short_classes::regex_14_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_14_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1488,10 +1357,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_14_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_14_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1499,19 +1369,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_14_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_14_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_14_matcher::to_string() -> std::string{return R"([\w])"; } - + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_14_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_14_matcher::to_string() -> std::string{return R"([\w])"; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_15_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_15_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1526,10 +1396,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_15_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_15_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1537,19 +1408,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_15_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_15_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_15_matcher::to_string() -> std::string{return R"([\W])"; } - + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_15_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_15_matcher::to_string() -> std::string{return R"([\W])"; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_16_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_16_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1564,10 +1435,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_16_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_16_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1575,19 +1447,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_16_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_16_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_16_matcher::to_string() -> std::string{return R"([\W])"; } + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_16_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_16_matcher::to_string() -> std::string{return R"([\W])"; } - - template [[nodiscard]] auto test_tests_07_short_classes::regex_17_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_17_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1630,10 +1502,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_17_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_17_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1641,19 +1514,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_17_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_17_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_17_matcher::to_string() -> std::string{return R"(a[\s]b)"; } - + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_17_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_17_matcher::to_string() -> std::string{return R"(a[\s]b)"; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_18_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_18_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1696,10 +1569,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_18_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_18_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1707,19 +1581,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_18_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_18_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_18_matcher::to_string() -> std::string{return R"(a[\s]b)"; } - + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_18_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_18_matcher::to_string() -> std::string{return R"(a[\s]b)"; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_19_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_19_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1762,10 +1636,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_19_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_19_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1773,19 +1648,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_19_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_19_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_19_matcher::to_string() -> std::string{return R"(a[\S]b)"; } + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_19_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_19_matcher::to_string() -> std::string{return R"(a[\S]b)"; } - - template [[nodiscard]] auto test_tests_07_short_classes::regex_20_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_20_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1828,10 +1703,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_20_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_20_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1839,19 +1715,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_20_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_20_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_20_matcher::to_string() -> std::string{return R"(a[\S]b)"; } - + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_20_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_20_matcher::to_string() -> std::string{return R"(a[\S]b)"; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_21_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_21_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1866,10 +1742,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_21_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_21_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1877,19 +1754,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_21_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_21_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_21_matcher::to_string() -> std::string{return R"([\d])"; } - + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_21_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_21_matcher::to_string() -> std::string{return R"([\d])"; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_22_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_22_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1904,10 +1781,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_22_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_22_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1915,19 +1793,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_22_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_22_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_22_matcher::to_string() -> std::string{return R"([\d])"; } + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_22_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_22_matcher::to_string() -> std::string{return R"([\d])"; } - - template [[nodiscard]] auto test_tests_07_short_classes::regex_23_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_23_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1942,10 +1820,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_23_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_23_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1953,19 +1832,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_23_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_23_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_23_matcher::to_string() -> std::string{return R"([\D])"; } - + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_23_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_23_matcher::to_string() -> std::string{return R"([\D])"; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_24_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_24_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1980,10 +1859,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_24_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_07_short_classes::regex_24_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1991,15 +1871,16 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_07_short_classes::regex_24_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_07_short_classes::regex_24_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_07_short_classes::regex_24_matcher::to_string() -> std::string{return R"([\D])"; } + template [[nodiscard]] constexpr auto test_tests_07_short_classes::regex_24_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_07_short_classes::regex_24_matcher::to_string() -> std::string{return R"([\D])"; } -#line 219 "pure2-regex_07_short_classes.cpp2" +#line 220 "pure2-regex_07_short_classes.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_07_short_classes()); } diff --git a/regression-tests/test-results/pure2-regex_08_alternatives.cpp b/regression-tests/test-results/pure2-regex_08_alternatives.cpp index fce990d18e..2151ebbb5c 100644 --- a/regression-tests/test-results/pure2-regex_08_alternatives.cpp +++ b/regression-tests/test-results/pure2-regex_08_alternatives.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_08_alternatives.cpp2" -#line 165 "pure2-regex_08_alternatives.cpp2" +#line 166 "pure2-regex_08_alternatives.cpp2" class test_tests_08_alternatives; @@ -18,52 +18,46 @@ class test_tests_08_alternatives; #line 1 "pure2-regex_08_alternatives.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_08_alternatives.cpp2" +#line 113 "pure2-regex_08_alternatives.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_08_alternatives.cpp2" +#line 125 "pure2-regex_08_alternatives.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_08_alternatives.cpp2" +#line 166 "pure2-regex_08_alternatives.cpp2" class test_tests_08_alternatives { -#line 168 "pure2-regex_08_alternatives.cpp2" +#line 169 "pure2-regex_08_alternatives.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -71,40 +65,34 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -112,13 +100,13 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_02 {}; + public: cpp2::regex::regular_expression> regex_02 {}; public: test_tests_08_alternatives() = default; public: test_tests_08_alternatives(test_tests_08_alternatives const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_08_alternatives const&) -> void = delete; -#line 174 "pure2-regex_08_alternatives.cpp2" +#line 175 "pure2-regex_08_alternatives.cpp2" }; auto main() -> int; @@ -222,6 +210,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -237,7 +226,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_08_alternatives.cpp2" +#line 113 "pure2-regex_08_alternatives.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -250,7 +239,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_08_alternatives.cpp2" +#line 125 "pure2-regex_08_alternatives.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -291,7 +280,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 168 "pure2-regex_08_alternatives.cpp2" +#line 169 "pure2-regex_08_alternatives.cpp2" auto test_tests_08_alternatives::run() const& -> void{ std::cout << "Running tests_08_alternatives:" << std::endl; test(regex_01, "01", R"(ab|cd)", "abc", "y", R"($&)", "ab"); @@ -302,8 +291,7 @@ template auto test(M const& regex, cpp2::impl::in id, c - - template [[nodiscard]] auto test_tests_08_alternatives::regex_01_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_08_alternatives::regex_01_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -331,11 +319,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_08_alternatives::regex_01_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_08_alternatives::regex_01_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -363,11 +352,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_08_alternatives::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_08_alternatives::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -381,11 +371,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_08_alternatives::regex_01_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_08_alternatives::regex_01_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -399,10 +390,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_08_alternatives::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_08_alternatives::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -410,19 +402,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_08_alternatives::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_08_alternatives::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_08_alternatives::regex_01_matcher::to_string() -> std::string{return R"(ab|cd)"; } + template [[nodiscard]] constexpr auto test_tests_08_alternatives::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_08_alternatives::regex_01_matcher::to_string() -> std::string{return R"(ab|cd)"; } - - template [[nodiscard]] auto test_tests_08_alternatives::regex_02_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_08_alternatives::regex_02_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -450,11 +442,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_08_alternatives::regex_02_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_08_alternatives::regex_02_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -482,11 +475,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_08_alternatives::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_08_alternatives::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -500,11 +494,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_08_alternatives::regex_02_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_08_alternatives::regex_02_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -518,10 +513,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_08_alternatives::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_08_alternatives::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -529,15 +525,16 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_08_alternatives::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_08_alternatives::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_08_alternatives::regex_02_matcher::to_string() -> std::string{return R"(ab|cd)"; } + template [[nodiscard]] constexpr auto test_tests_08_alternatives::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_08_alternatives::regex_02_matcher::to_string() -> std::string{return R"(ab|cd)"; } -#line 175 "pure2-regex_08_alternatives.cpp2" +#line 176 "pure2-regex_08_alternatives.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_08_alternatives()); } diff --git a/regression-tests/test-results/pure2-regex_09_groups.cpp b/regression-tests/test-results/pure2-regex_09_groups.cpp index 041fd61204..8a597554cc 100644 --- a/regression-tests/test-results/pure2-regex_09_groups.cpp +++ b/regression-tests/test-results/pure2-regex_09_groups.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_09_groups.cpp2" -#line 165 "pure2-regex_09_groups.cpp2" +#line 166 "pure2-regex_09_groups.cpp2" class test_tests_09_groups; @@ -18,37 +18,31 @@ class test_tests_09_groups; #line 1 "pure2-regex_09_groups.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_09_groups.cpp2" +#line 113 "pure2-regex_09_groups.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_09_groups.cpp2" +#line 125 "pure2-regex_09_groups.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_09_groups.cpp2" +#line 166 "pure2-regex_09_groups.cpp2" class test_tests_09_groups { -#line 177 "pure2-regex_09_groups.cpp2" +#line 178 "pure2-regex_09_groups.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -56,25 +50,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -82,25 +70,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_02 {}; public: class regex_03_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_03_matcher() = default; public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -108,25 +90,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_03 {}; public: class regex_04_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_04_matcher() = default; public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -134,25 +110,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_04 {}; public: class regex_05_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_05_matcher() = default; public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -160,25 +130,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_05 {}; public: class regex_06_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_06_matcher() = default; public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -186,25 +150,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_06 {}; public: class regex_07_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_06 {}; public: template class regex_07_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_07_matcher() = default; public: regex_07_matcher(regex_07_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -212,25 +170,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_07 {}; public: class regex_08_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_07 {}; public: template class regex_08_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_08_matcher() = default; public: regex_08_matcher(regex_08_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -238,25 +190,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_08 {}; public: class regex_09_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_08 {}; public: template class regex_09_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_09_matcher() = default; public: regex_09_matcher(regex_09_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -264,25 +210,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_09 {}; public: class regex_10_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_09 {}; public: template class regex_10_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_10_matcher() = default; public: regex_10_matcher(regex_10_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -290,25 +230,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_10 {}; public: class regex_11_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_10 {}; public: template class regex_11_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_11_matcher() = default; public: regex_11_matcher(regex_11_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -316,13 +250,13 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_11 {}; + public: cpp2::regex::regular_expression> regex_11 {}; public: test_tests_09_groups() = default; public: test_tests_09_groups(test_tests_09_groups const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_09_groups const&) -> void = delete; -#line 192 "pure2-regex_09_groups.cpp2" +#line 193 "pure2-regex_09_groups.cpp2" }; auto main() -> int; @@ -426,6 +360,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -441,7 +376,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_09_groups.cpp2" +#line 113 "pure2-regex_09_groups.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -454,7 +389,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_09_groups.cpp2" +#line 125 "pure2-regex_09_groups.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -495,7 +430,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 177 "pure2-regex_09_groups.cpp2" +#line 178 "pure2-regex_09_groups.cpp2" auto test_tests_09_groups::run() const& -> void{ std::cout << "Running tests_09_groups:" << std::endl; test(regex_01, "01", R"(()ef)", "def", "y", R"($&-$1)", "ef-"); @@ -515,8 +450,7 @@ template auto test(M const& regex, cpp2::impl::in id, c - - template [[nodiscard]] auto test_tests_09_groups::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -557,10 +491,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -568,19 +503,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_09_groups::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_09_groups::regex_01_matcher::to_string() -> std::string{return R"(()ef)"; } + template [[nodiscard]] constexpr auto test_tests_09_groups::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_09_groups::regex_01_matcher::to_string() -> std::string{return R"(()ef)"; } - - template [[nodiscard]] auto test_tests_09_groups::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -621,10 +556,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -632,19 +568,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_09_groups::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_09_groups::regex_02_matcher::to_string() -> std::string{return R"(()ef)"; } - + template [[nodiscard]] constexpr auto test_tests_09_groups::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_09_groups::regex_02_matcher::to_string() -> std::string{return R"(()ef)"; } - template [[nodiscard]] auto test_tests_09_groups::regex_03_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -685,10 +621,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_03_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -696,19 +633,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_03_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_09_groups::regex_03_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_09_groups::regex_03_matcher::to_string() -> std::string{return R"(()ef)"; } - + template [[nodiscard]] constexpr auto test_tests_09_groups::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_09_groups::regex_03_matcher::to_string() -> std::string{return R"(()ef)"; } - template [[nodiscard]] auto test_tests_09_groups::regex_04_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -749,10 +686,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_04_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -760,19 +698,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_04_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_09_groups::regex_04_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_09_groups::regex_04_matcher::to_string() -> std::string{return R"(()ef)"; } + template [[nodiscard]] constexpr auto test_tests_09_groups::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_09_groups::regex_04_matcher::to_string() -> std::string{return R"(()ef)"; } - - template [[nodiscard]] auto test_tests_09_groups::regex_05_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -813,10 +751,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_05_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -824,19 +763,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_05_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_09_groups::regex_05_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_09_groups::regex_05_matcher::to_string() -> std::string{return R"(()ef)"; } - + template [[nodiscard]] constexpr auto test_tests_09_groups::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_09_groups::regex_05_matcher::to_string() -> std::string{return R"(()ef)"; } - template [[nodiscard]] auto test_tests_09_groups::regex_06_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -890,10 +829,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_06_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -901,19 +841,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_06_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_09_groups::regex_06_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_09_groups::regex_06_matcher::to_string() -> std::string{return R"(((a)))"; } - + template [[nodiscard]] constexpr auto test_tests_09_groups::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_09_groups::regex_06_matcher::to_string() -> std::string{return R"(((a)))"; } - template [[nodiscard]] auto test_tests_09_groups::regex_07_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_07_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -967,10 +907,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_07_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_07_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -978,19 +919,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_07_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_09_groups::regex_07_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_09_groups::regex_07_matcher::to_string() -> std::string{return R"(((a)))"; } + template [[nodiscard]] constexpr auto test_tests_09_groups::regex_07_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_09_groups::regex_07_matcher::to_string() -> std::string{return R"(((a)))"; } - - template [[nodiscard]] auto test_tests_09_groups::regex_08_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_08_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1044,10 +985,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_08_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_08_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1055,19 +997,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_08_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_09_groups::regex_08_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_09_groups::regex_08_matcher::to_string() -> std::string{return R"(((a)))"; } - + template [[nodiscard]] constexpr auto test_tests_09_groups::regex_08_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_09_groups::regex_08_matcher::to_string() -> std::string{return R"(((a)))"; } - template [[nodiscard]] auto test_tests_09_groups::regex_09_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_09_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1149,10 +1091,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_09_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_09_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1160,19 +1103,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_09_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_09_groups::regex_09_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_09_groups::regex_09_matcher::to_string() -> std::string{return R"((a)b(c))"; } - + template [[nodiscard]] constexpr auto test_tests_09_groups::regex_09_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_09_groups::regex_09_matcher::to_string() -> std::string{return R"((a)b(c))"; } - template [[nodiscard]] auto test_tests_09_groups::regex_10_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_10_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1254,10 +1197,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_10_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_10_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1265,19 +1209,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_10_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_09_groups::regex_10_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_09_groups::regex_10_matcher::to_string() -> std::string{return R"((a)b(c))"; } + template [[nodiscard]] constexpr auto test_tests_09_groups::regex_10_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_09_groups::regex_10_matcher::to_string() -> std::string{return R"((a)b(c))"; } - - template [[nodiscard]] auto test_tests_09_groups::regex_11_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_11_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1359,10 +1303,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_11_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_09_groups::regex_11_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1370,15 +1315,16 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_09_groups::regex_11_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_09_groups::regex_11_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_09_groups::regex_11_matcher::to_string() -> std::string{return R"((a)b(c))"; } + template [[nodiscard]] constexpr auto test_tests_09_groups::regex_11_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_09_groups::regex_11_matcher::to_string() -> std::string{return R"((a)b(c))"; } -#line 193 "pure2-regex_09_groups.cpp2" +#line 194 "pure2-regex_09_groups.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_09_groups()); } diff --git a/regression-tests/test-results/pure2-regex_10_escapes.cpp b/regression-tests/test-results/pure2-regex_10_escapes.cpp index fe0137c116..f45381a1ca 100644 --- a/regression-tests/test-results/pure2-regex_10_escapes.cpp +++ b/regression-tests/test-results/pure2-regex_10_escapes.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_10_escapes.cpp2" -#line 165 "pure2-regex_10_escapes.cpp2" +#line 166 "pure2-regex_10_escapes.cpp2" class test_tests_10_escapes; @@ -18,37 +18,31 @@ class test_tests_10_escapes; #line 1 "pure2-regex_10_escapes.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_10_escapes.cpp2" +#line 113 "pure2-regex_10_escapes.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_10_escapes.cpp2" +#line 125 "pure2-regex_10_escapes.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_10_escapes.cpp2" +#line 166 "pure2-regex_10_escapes.cpp2" class test_tests_10_escapes { -#line 186 "pure2-regex_10_escapes.cpp2" +#line 187 "pure2-regex_10_escapes.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -56,35 +50,29 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -92,35 +80,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_02 {}; public: class regex_03_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_03_matcher() = default; public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -128,25 +110,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_03 {}; public: class regex_04_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_04_matcher() = default; public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -154,35 +130,29 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_04 {}; public: class regex_05_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_05_matcher() = default; public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -190,35 +160,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_05 {}; public: class regex_06_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_06_matcher() = default; public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -226,35 +190,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_06 {}; public: class regex_07_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_06 {}; public: template class regex_07_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_07_matcher() = default; public: regex_07_matcher(regex_07_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -262,25 +220,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_07 {}; public: class regex_08_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_07 {}; public: template class regex_08_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_08_matcher() = default; public: regex_08_matcher(regex_08_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -288,25 +240,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_08 {}; public: class regex_09_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_08 {}; public: template class regex_09_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_09_matcher() = default; public: regex_09_matcher(regex_09_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -314,25 +260,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_09 {}; public: class regex_10_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_09 {}; public: template class regex_10_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_10_matcher() = default; public: regex_10_matcher(regex_10_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -340,35 +280,29 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_10 {}; public: class regex_11_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_10 {}; public: template class regex_11_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_11_matcher() = default; public: regex_11_matcher(regex_11_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -376,35 +310,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_11 {}; public: class regex_12_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_11 {}; public: template class regex_12_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_12_matcher() = default; public: regex_12_matcher(regex_12_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -412,35 +340,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_12 {}; public: class regex_13_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_12 {}; public: template class regex_13_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_13_matcher() = default; public: regex_13_matcher(regex_13_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -448,25 +370,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_13 {}; public: class regex_14_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_13 {}; public: template class regex_14_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_14_matcher() = default; public: regex_14_matcher(regex_14_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -474,25 +390,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_14 {}; public: class regex_15_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_14 {}; public: template class regex_15_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_15_matcher() = default; public: regex_15_matcher(regex_15_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -500,25 +410,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_15 {}; public: class regex_16_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_15 {}; public: template class regex_16_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_16_matcher() = default; public: regex_16_matcher(regex_16_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -526,25 +430,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_16 {}; public: class regex_17_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_16 {}; public: template class regex_17_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_17_matcher() = default; public: regex_17_matcher(regex_17_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -552,25 +450,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_17 {}; public: class regex_18_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_17 {}; public: template class regex_18_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_18_matcher() = default; public: regex_18_matcher(regex_18_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -578,25 +470,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_18 {}; public: class regex_19_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_18 {}; public: template class regex_19_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_19_matcher() = default; public: regex_19_matcher(regex_19_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -604,25 +490,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_19 {}; public: class regex_20_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_19 {}; public: template class regex_20_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_20_matcher() = default; public: regex_20_matcher(regex_20_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -630,13 +510,13 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_20 {}; + public: cpp2::regex::regular_expression> regex_20 {}; public: test_tests_10_escapes() = default; public: test_tests_10_escapes(test_tests_10_escapes const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_10_escapes const&) -> void = delete; -#line 210 "pure2-regex_10_escapes.cpp2" +#line 211 "pure2-regex_10_escapes.cpp2" }; auto main() -> int; @@ -740,6 +620,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -755,7 +636,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_10_escapes.cpp2" +#line 113 "pure2-regex_10_escapes.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -768,7 +649,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_10_escapes.cpp2" +#line 125 "pure2-regex_10_escapes.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -809,7 +690,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 186 "pure2-regex_10_escapes.cpp2" +#line 187 "pure2-regex_10_escapes.cpp2" auto test_tests_10_escapes::run() const& -> void{ std::cout << "Running tests_10_escapes:" << std::endl; test(regex_01, "01", R"(a\(b)", "a(b", "y", R"($&-$1)", "a(b-"); @@ -838,8 +719,7 @@ template auto test(M const& regex, cpp2::impl::in id, c - - template [[nodiscard]] auto test_tests_10_escapes::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -867,10 +747,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -878,19 +759,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_01_matcher::to_string() -> std::string{return R"(a\(b)"; } + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_01_matcher::to_string() -> std::string{return R"(a\(b)"; } - - template [[nodiscard]] auto test_tests_10_escapes::regex_02_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_02_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -918,11 +799,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -950,11 +832,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_02_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_02_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -982,10 +865,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -993,19 +877,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_02_matcher::to_string() -> std::string{return R"(a\(*b)"; } - + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_02_matcher::to_string() -> std::string{return R"(a\(*b)"; } - template [[nodiscard]] auto test_tests_10_escapes::regex_03_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_03_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1033,11 +917,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_03_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1065,11 +950,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_03_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_03_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1097,10 +983,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_03_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1108,19 +995,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_03_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_03_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_03_matcher::to_string() -> std::string{return R"(a\(*b)"; } - + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_03_matcher::to_string() -> std::string{return R"(a\(*b)"; } - template [[nodiscard]] auto test_tests_10_escapes::regex_04_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1148,10 +1035,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_04_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1159,19 +1047,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_04_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_04_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_04_matcher::to_string() -> std::string{return R"(a\\b)"; } + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_04_matcher::to_string() -> std::string{return R"(a\\b)"; } - - template [[nodiscard]] auto test_tests_10_escapes::regex_05_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_05_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1186,11 +1074,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_05_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1219,11 +1108,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_05_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_05_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1263,10 +1153,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_05_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1274,19 +1165,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_05_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_05_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_05_matcher::to_string() -> std::string{return R"(foo(\h+)bar)"; } - + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_05_matcher::to_string() -> std::string{return R"(foo(\h+)bar)"; } - template [[nodiscard]] auto test_tests_10_escapes::regex_06_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_06_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1301,11 +1192,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_06_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1320,11 +1212,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_06_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_06_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1364,10 +1257,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_06_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1375,19 +1269,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_06_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_06_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_06_matcher::to_string() -> std::string{return R"((\H+)(\h))"; } + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_06_matcher::to_string() -> std::string{return R"((\H+)(\h))"; } - - template [[nodiscard]] auto test_tests_10_escapes::regex_07_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_07_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1402,11 +1296,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_07_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_07_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1421,11 +1316,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_07_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_07_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1465,10 +1361,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_07_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_07_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1476,19 +1373,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_07_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_07_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_07_matcher::to_string() -> std::string{return R"((\h+)(\H))"; } - + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_07_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_07_matcher::to_string() -> std::string{return R"((\h+)(\H))"; } - template [[nodiscard]] auto test_tests_10_escapes::regex_08_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_08_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1544,10 +1441,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_08_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_08_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1555,19 +1453,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_08_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_08_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_08_matcher::to_string() -> std::string{return R"(foo(\h)bar)"; } - + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_08_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_08_matcher::to_string() -> std::string{return R"(foo(\h)bar)"; } - template [[nodiscard]] auto test_tests_10_escapes::regex_09_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_09_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1609,10 +1507,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_09_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_09_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1620,19 +1519,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_09_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_09_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_09_matcher::to_string() -> std::string{return R"((\H)(\h))"; } + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_09_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_09_matcher::to_string() -> std::string{return R"((\H)(\h))"; } - - template [[nodiscard]] auto test_tests_10_escapes::regex_10_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_10_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1674,10 +1573,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_10_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_10_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1685,19 +1585,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_10_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_10_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_10_matcher::to_string() -> std::string{return R"((\h)(\H))"; } - + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_10_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_10_matcher::to_string() -> std::string{return R"((\h)(\H))"; } - template [[nodiscard]] auto test_tests_10_escapes::regex_11_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_11_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1712,11 +1612,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_11_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_11_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1745,11 +1646,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_11_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_11_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1789,10 +1691,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_11_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_11_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1800,19 +1703,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_11_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_11_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_11_matcher::to_string() -> std::string{return R"(foo(\v+)bar)"; } + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_11_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_11_matcher::to_string() -> std::string{return R"(foo(\v+)bar)"; } - - template [[nodiscard]] auto test_tests_10_escapes::regex_12_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_12_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1827,11 +1730,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_12_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_12_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1846,11 +1750,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_12_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_12_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1890,10 +1795,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_12_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_12_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1901,19 +1807,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_12_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_12_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_12_matcher::to_string() -> std::string{return R"((\V+)(\v))"; } - + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_12_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_12_matcher::to_string() -> std::string{return R"((\V+)(\v))"; } - template [[nodiscard]] auto test_tests_10_escapes::regex_13_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_13_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1928,11 +1834,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_13_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_13_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1947,11 +1854,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_13_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_13_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1991,10 +1899,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_13_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_13_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2002,19 +1911,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_13_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_13_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_13_matcher::to_string() -> std::string{return R"((\v+)(\V))"; } - + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_13_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_13_matcher::to_string() -> std::string{return R"((\v+)(\V))"; } - template [[nodiscard]] auto test_tests_10_escapes::regex_14_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_14_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2070,10 +1979,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_14_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_14_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2081,19 +1991,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_14_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_14_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_14_matcher::to_string() -> std::string{return R"(foo(\v)bar)"; } + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_14_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_14_matcher::to_string() -> std::string{return R"(foo(\v)bar)"; } - - template [[nodiscard]] auto test_tests_10_escapes::regex_15_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_15_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2135,10 +2045,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_15_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_15_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2146,19 +2057,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_15_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_15_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_15_matcher::to_string() -> std::string{return R"((\V)(\v))"; } - + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_15_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_15_matcher::to_string() -> std::string{return R"((\V)(\v))"; } - template [[nodiscard]] auto test_tests_10_escapes::regex_16_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_16_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2200,10 +2111,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_16_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_16_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2211,19 +2123,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_16_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_16_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_16_matcher::to_string() -> std::string{return R"((\v)(\V))"; } + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_16_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_16_matcher::to_string() -> std::string{return R"((\v)(\V))"; } - - template [[nodiscard]] auto test_tests_10_escapes::regex_17_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_17_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2251,10 +2163,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_17_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_17_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2262,19 +2175,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_17_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_17_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_17_matcher::to_string() -> std::string{return R"(foo\t\n\r\f\a\ebar)"; } - + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_17_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_17_matcher::to_string() -> std::string{return R"(foo\t\n\r\f\a\ebar)"; } - template [[nodiscard]] auto test_tests_10_escapes::regex_18_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_18_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2317,10 +2230,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_18_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_18_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2328,19 +2242,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_18_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_18_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_18_matcher::to_string() -> std::string{return R"(foo\Kbar)"; } - + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_18_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_18_matcher::to_string() -> std::string{return R"(foo\Kbar)"; } - template [[nodiscard]] auto test_tests_10_escapes::regex_19_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_19_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2368,10 +2282,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_19_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_19_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2379,19 +2294,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_19_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_19_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_19_matcher::to_string() -> std::string{return R"(\x41\x42)"; } + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_19_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_19_matcher::to_string() -> std::string{return R"(\x41\x42)"; } - - template [[nodiscard]] auto test_tests_10_escapes::regex_20_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_20_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2419,10 +2334,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_20_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_10_escapes::regex_20_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2430,15 +2346,16 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_10_escapes::regex_20_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_10_escapes::regex_20_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_10_escapes::regex_20_matcher::to_string() -> std::string{return R"(\101\o{102})"; } + template [[nodiscard]] constexpr auto test_tests_10_escapes::regex_20_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_10_escapes::regex_20_matcher::to_string() -> std::string{return R"(\101\o{102})"; } -#line 211 "pure2-regex_10_escapes.cpp2" +#line 212 "pure2-regex_10_escapes.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_10_escapes()); } diff --git a/regression-tests/test-results/pure2-regex_11_group_references.cpp b/regression-tests/test-results/pure2-regex_11_group_references.cpp index 64aa1f5c29..acc577c0a8 100644 --- a/regression-tests/test-results/pure2-regex_11_group_references.cpp +++ b/regression-tests/test-results/pure2-regex_11_group_references.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_11_group_references.cpp2" -#line 165 "pure2-regex_11_group_references.cpp2" +#line 166 "pure2-regex_11_group_references.cpp2" class test_tests_11_group_references; @@ -18,37 +18,31 @@ class test_tests_11_group_references; #line 1 "pure2-regex_11_group_references.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_11_group_references.cpp2" +#line 113 "pure2-regex_11_group_references.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_11_group_references.cpp2" +#line 125 "pure2-regex_11_group_references.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_11_group_references.cpp2" +#line 166 "pure2-regex_11_group_references.cpp2" class test_tests_11_group_references { -#line 190 "pure2-regex_11_group_references.cpp2" +#line 191 "pure2-regex_11_group_references.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -56,25 +50,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -82,45 +70,39 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_02 {}; public: class regex_03_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_03_matcher() = default; public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -128,25 +110,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_03 {}; public: class regex_04_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_04_matcher() = default; public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -154,25 +130,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_04 {}; public: class regex_05_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_05_matcher() = default; public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -180,25 +150,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_05 {}; public: class regex_06_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_06_matcher() = default; public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -206,25 +170,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_06 {}; public: class regex_07_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_06 {}; public: template class regex_07_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_07_matcher() = default; public: regex_07_matcher(regex_07_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -232,25 +190,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_07 {}; public: class regex_08_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_07 {}; public: template class regex_08_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_08_matcher() = default; public: regex_08_matcher(regex_08_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -258,25 +210,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_08 {}; public: class regex_09_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_08 {}; public: template class regex_09_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_09_matcher() = default; public: regex_09_matcher(regex_09_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -284,45 +230,39 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_09 {}; public: class regex_10_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_09 {}; public: template class regex_10_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_10_matcher() = default; public: regex_10_matcher(regex_10_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -330,25 +270,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_10 {}; public: class regex_11_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_10 {}; public: template class regex_11_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_11_matcher() = default; public: regex_11_matcher(regex_11_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -356,25 +290,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_11 {}; public: class regex_12_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_11 {}; public: template class regex_12_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_12_matcher() = default; public: regex_12_matcher(regex_12_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -382,25 +310,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_12 {}; public: class regex_13_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_12 {}; public: template class regex_13_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_13_matcher() = default; public: regex_13_matcher(regex_13_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -408,25 +330,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_13 {}; public: class regex_14_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_13 {}; public: template class regex_14_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_14_matcher() = default; public: regex_14_matcher(regex_14_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -434,25 +350,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_14 {}; public: class regex_15_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_14 {}; public: template class regex_15_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_15_matcher() = default; public: regex_15_matcher(regex_15_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -460,25 +370,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_15 {}; public: class regex_16_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_15 {}; public: template class regex_16_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_16_matcher() = default; public: regex_16_matcher(regex_16_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -486,25 +390,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_16 {}; public: class regex_17_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_16 {}; public: template class regex_17_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_17_matcher() = default; public: regex_17_matcher(regex_17_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -512,25 +410,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_17 {}; public: class regex_18_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_17 {}; public: template class regex_18_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_18_matcher() = default; public: regex_18_matcher(regex_18_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -538,25 +430,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_18 {}; public: class regex_19_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_18 {}; public: template class regex_19_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_19_matcher() = default; public: regex_19_matcher(regex_19_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -564,25 +450,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_19 {}; public: class regex_20_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_19 {}; public: template class regex_20_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_20_matcher() = default; public: regex_20_matcher(regex_20_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -590,45 +470,39 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_20 {}; public: class regex_21_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_20 {}; public: template class regex_21_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_21_matcher() = default; public: regex_21_matcher(regex_21_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -636,45 +510,39 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_21 {}; public: class regex_22_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_21 {}; public: template class regex_22_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_22_matcher() = default; public: regex_22_matcher(regex_22_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -682,45 +550,39 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_22 {}; public: class regex_23_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_22 {}; public: template class regex_23_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_23_matcher() = default; public: regex_23_matcher(regex_23_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -728,45 +590,39 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_23 {}; public: class regex_24_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_23 {}; public: template class regex_24_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_24_matcher() = default; public: regex_24_matcher(regex_24_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -774,13 +630,13 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_24 {}; + public: cpp2::regex::regular_expression> regex_24 {}; public: test_tests_11_group_references() = default; public: test_tests_11_group_references(test_tests_11_group_references const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_11_group_references const&) -> void = delete; -#line 218 "pure2-regex_11_group_references.cpp2" +#line 219 "pure2-regex_11_group_references.cpp2" }; auto main() -> int; @@ -884,6 +740,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -899,7 +756,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_11_group_references.cpp2" +#line 113 "pure2-regex_11_group_references.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -912,7 +769,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_11_group_references.cpp2" +#line 125 "pure2-regex_11_group_references.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -953,7 +810,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 190 "pure2-regex_11_group_references.cpp2" +#line 191 "pure2-regex_11_group_references.cpp2" auto test_tests_11_group_references::run() const& -> void{ std::cout << "Running tests_11_group_references:" << std::endl; test(regex_01, "01", R"((foo)(\g-2))", "foofoo", "y", R"($1-$2)", "foo-foo"); @@ -986,8 +843,7 @@ template auto test(M const& regex, cpp2::impl::in id, c - - template [[nodiscard]] auto test_tests_11_group_references::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1019,7 +875,7 @@ int i{0}; auto tmp_1 {cpp2::regex::make_on_return(cpp2::move(tmp_1_func))}; static_cast(cpp2::move(tmp_1)); ctx.set_group_start(2, r.pos); - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} ctx.set_group_end(2, r.pos); auto tmp_2_func { @@ -1042,10 +898,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1053,19 +910,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_11_group_references::regex_01_matcher::to_string() -> std::string{return R"((foo)(\g-2))"; } + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_01_matcher::to_string() -> std::string{return R"((foo)(\g-2))"; } - - template [[nodiscard]] auto test_tests_11_group_references::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1097,7 +954,7 @@ int i{0}; auto tmp_1 {cpp2::regex::make_on_return(cpp2::move(tmp_1_func))}; static_cast(cpp2::move(tmp_1)); ctx.set_group_start(2, r.pos); - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} ctx.set_group_end(2, r.pos); auto tmp_2_func { @@ -1138,7 +995,7 @@ int i{0}; auto tmp_4 {cpp2::regex::make_on_return(cpp2::move(tmp_4_func))}; static_cast(cpp2::move(tmp_4)); ctx.set_group_start(4, r.pos); - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} ctx.set_group_end(4, r.pos); auto tmp_5_func { @@ -1161,10 +1018,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1172,19 +1030,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_11_group_references::regex_02_matcher::to_string() -> std::string{return R"((foo)(\g-2)(foo)(\g-2))"; } - + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_02_matcher::to_string() -> std::string{return R"((foo)(\g-2)(foo)(\g-2))"; } - template [[nodiscard]] auto test_tests_11_group_references::regex_03_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_03_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1199,11 +1057,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_03_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1219,11 +1078,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_03_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_03_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1238,11 +1098,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_03_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_03_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1272,7 +1133,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} ctx.set_group_end(1, r.pos); auto tmp_2_func { @@ -1297,11 +1158,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_03_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_03_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1331,7 +1193,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} ctx.set_group_end(3, r.pos); auto tmp_5_func { @@ -1354,10 +1216,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_03_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1365,19 +1228,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_03_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_03_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_11_group_references::regex_03_matcher::to_string() -> std::string{return R"((([abc]+) \g-1)(([abc]+) \g{-1}))"; } - + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_03_matcher::to_string() -> std::string{return R"((([abc]+) \g-1)(([abc]+) \g{-1}))"; } - template [[nodiscard]] auto test_tests_11_group_references::regex_04_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1462,9 +1325,9 @@ int i{0}; auto tmp_5 {cpp2::regex::make_on_return(cpp2::move(tmp_5_func))}; static_cast(cpp2::move(tmp_5)); - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -1475,10 +1338,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_04_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1486,19 +1350,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_04_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_04_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_11_group_references::regex_04_matcher::to_string() -> std::string{return R"((a)(b)(c)\g1\g2\g3)"; } + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_04_matcher::to_string() -> std::string{return R"((a)(b)(c)\g1\g2\g3)"; } - - template [[nodiscard]] auto test_tests_11_group_references::regex_05_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1543,7 +1407,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -1554,10 +1418,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_05_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1565,18 +1430,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_05_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_05_matcher::get_named_group_index(auto const& name) -> int{ if (name == "n") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_05_matcher::to_string() -> std::string{return R"(/(?'n'foo) \g{n}/)"; } - + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_05_matcher::to_string() -> std::string{return R"(/(?'n'foo) \g{n}/)"; } - template [[nodiscard]] auto test_tests_11_group_references::regex_06_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1621,7 +1486,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -1632,10 +1497,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_06_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1643,18 +1509,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_06_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_06_matcher::get_named_group_index(auto const& name) -> int{ if (name == "n") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_06_matcher::to_string() -> std::string{return R"(/(?'n'foo) \g{ n }/)"; } - + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_06_matcher::to_string() -> std::string{return R"(/(?'n'foo) \g{ n }/)"; } - template [[nodiscard]] auto test_tests_11_group_references::regex_07_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_07_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1699,7 +1565,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -1710,10 +1576,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_07_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_07_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1721,18 +1588,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_07_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_07_matcher::get_named_group_index(auto const& name) -> int{ if (name == "n") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_07_matcher::to_string() -> std::string{return R"(/(?'n'foo) \g{n}/)"; } + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_07_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_07_matcher::to_string() -> std::string{return R"(/(?'n'foo) \g{n}/)"; } - - template [[nodiscard]] auto test_tests_11_group_references::regex_08_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_08_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1777,7 +1644,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -1788,10 +1655,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_08_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_08_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1799,18 +1667,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_08_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_08_matcher::get_named_group_index(auto const& name) -> int{ if (name == "n") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_08_matcher::to_string() -> std::string{return R"(/(?foo) \g{n}/)"; } - + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_08_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_08_matcher::to_string() -> std::string{return R"(/(?foo) \g{n}/)"; } - template [[nodiscard]] auto test_tests_11_group_references::regex_09_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_09_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1855,7 +1723,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -1866,10 +1734,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_09_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_09_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1877,18 +1746,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_09_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_09_matcher::get_named_group_index(auto const& name) -> int{ if (name == "n") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_09_matcher::to_string() -> std::string{return R"(/(?foo) \g{n}/)"; } - + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_09_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_09_matcher::to_string() -> std::string{return R"(/(?foo) \g{n}/)"; } - template [[nodiscard]] auto test_tests_11_group_references::regex_10_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_10_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1903,11 +1772,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_10_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_10_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1963,11 +1833,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_10_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_10_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1982,11 +1853,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_10_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_10_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2016,7 +1888,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} std::array str_tmp_5 {" "}; if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { @@ -2042,11 +1914,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_10_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_10_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2072,10 +1945,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_10_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_10_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2083,18 +1957,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_10_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_10_matcher::get_named_group_index(auto const& name) -> int{ if (name == "as") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_10_matcher::to_string() -> std::string{return R"(/(?as) (\w+) \g{as} (\w+)/)"; } + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_10_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_10_matcher::to_string() -> std::string{return R"(/(?as) (\w+) \g{as} (\w+)/)"; } - - template [[nodiscard]] auto test_tests_11_group_references::regex_11_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_11_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2139,7 +2013,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -2150,10 +2024,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_11_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_11_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2161,18 +2036,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_11_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_11_matcher::get_named_group_index(auto const& name) -> int{ if (name == "n") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_11_matcher::to_string() -> std::string{return R"(/(?'n'foo) \k/)"; } - + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_11_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_11_matcher::to_string() -> std::string{return R"(/(?'n'foo) \k/)"; } - template [[nodiscard]] auto test_tests_11_group_references::regex_12_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_12_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2217,7 +2092,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -2228,10 +2103,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_12_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_12_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2239,18 +2115,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_12_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_12_matcher::get_named_group_index(auto const& name) -> int{ if (name == "n") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_12_matcher::to_string() -> std::string{return R"(/(?'n'foo) \k/)"; } - + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_12_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_12_matcher::to_string() -> std::string{return R"(/(?'n'foo) \k/)"; } - template [[nodiscard]] auto test_tests_11_group_references::regex_13_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_13_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2295,7 +2171,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -2306,10 +2182,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_13_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_13_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2317,18 +2194,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_13_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_13_matcher::get_named_group_index(auto const& name) -> int{ if (name == "n") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_13_matcher::to_string() -> std::string{return R"(/(?foo) \k'n'/)"; } + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_13_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_13_matcher::to_string() -> std::string{return R"(/(?foo) \k'n'/)"; } - - template [[nodiscard]] auto test_tests_11_group_references::regex_14_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_14_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2373,7 +2250,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -2384,10 +2261,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_14_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_14_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2395,18 +2273,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_14_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_14_matcher::get_named_group_index(auto const& name) -> int{ if (name == "n") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_14_matcher::to_string() -> std::string{return R"(/(?foo) \k'n'/)"; } - + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_14_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_14_matcher::to_string() -> std::string{return R"(/(?foo) \k'n'/)"; } - template [[nodiscard]] auto test_tests_11_group_references::regex_15_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_15_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2451,7 +2329,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -2462,10 +2340,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_15_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_15_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2473,18 +2352,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_15_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_15_matcher::get_named_group_index(auto const& name) -> int{ if (name == "a1") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_15_matcher::to_string() -> std::string{return R"(/(?'a1'foo) \k'a1'/)"; } - + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_15_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_15_matcher::to_string() -> std::string{return R"(/(?'a1'foo) \k'a1'/)"; } - template [[nodiscard]] auto test_tests_11_group_references::regex_16_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_16_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2529,7 +2408,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -2540,10 +2419,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_16_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_16_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2551,18 +2431,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_16_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_16_matcher::get_named_group_index(auto const& name) -> int{ if (name == "a1") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_16_matcher::to_string() -> std::string{return R"(/(?foo) \k/)"; } + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_16_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_16_matcher::to_string() -> std::string{return R"(/(?foo) \k/)"; } - - template [[nodiscard]] auto test_tests_11_group_references::regex_17_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_17_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2607,7 +2487,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -2618,10 +2498,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_17_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_17_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2629,18 +2510,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_17_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_17_matcher::get_named_group_index(auto const& name) -> int{ if (name == "_") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_17_matcher::to_string() -> std::string{return R"(/(?'_'foo) \k'_'/)"; } - + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_17_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_17_matcher::to_string() -> std::string{return R"(/(?'_'foo) \k'_'/)"; } - template [[nodiscard]] auto test_tests_11_group_references::regex_18_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_18_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2685,7 +2566,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -2696,10 +2577,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_18_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_18_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2707,18 +2589,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_18_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_18_matcher::get_named_group_index(auto const& name) -> int{ if (name == "_") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_18_matcher::to_string() -> std::string{return R"(/(?<_>foo) \k<_>/)"; } - + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_18_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_18_matcher::to_string() -> std::string{return R"(/(?<_>foo) \k<_>/)"; } - template [[nodiscard]] auto test_tests_11_group_references::regex_19_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_19_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2763,7 +2645,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -2774,10 +2656,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_19_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_19_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2785,18 +2668,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_19_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_19_matcher::get_named_group_index(auto const& name) -> int{ if (name == "_0_") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_19_matcher::to_string() -> std::string{return R"(/(?'_0_'foo) \k'_0_'/)"; } + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_19_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_19_matcher::to_string() -> std::string{return R"(/(?'_0_'foo) \k'_0_'/)"; } - - template [[nodiscard]] auto test_tests_11_group_references::regex_20_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_20_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2841,7 +2724,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -2852,10 +2735,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_20_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_20_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2863,18 +2747,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_20_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_20_matcher::get_named_group_index(auto const& name) -> int{ if (name == "_0_") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_20_matcher::to_string() -> std::string{return R"(/(?<_0_>foo) \k<_0_>/)"; } - + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_20_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_20_matcher::to_string() -> std::string{return R"(/(?<_0_>foo) \k<_0_>/)"; } - template [[nodiscard]] auto test_tests_11_group_references::regex_21_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_21_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2889,11 +2773,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_21_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_21_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2949,11 +2834,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_21_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_21_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2968,11 +2854,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_21_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_21_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3002,7 +2889,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} std::array str_tmp_5 {" "}; if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { @@ -3028,11 +2915,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_21_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_21_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3058,10 +2946,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_21_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_21_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3069,18 +2958,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_21_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_21_matcher::get_named_group_index(auto const& name) -> int{ if (name == "as") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_21_matcher::to_string() -> std::string{return R"(/(?as) (\w+) \k (\w+)/)"; } - + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_21_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_21_matcher::to_string() -> std::string{return R"(/(?as) (\w+) \k (\w+)/)"; } - template [[nodiscard]] auto test_tests_11_group_references::regex_22_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_22_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3095,11 +2984,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_22_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_22_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3155,11 +3045,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_22_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_22_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3174,11 +3065,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_22_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_22_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3208,7 +3100,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} std::array str_tmp_5 {" "}; if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { @@ -3234,11 +3126,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_22_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_22_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3264,10 +3157,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_22_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_22_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3275,18 +3169,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_22_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_22_matcher::get_named_group_index(auto const& name) -> int{ if (name == "as") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_22_matcher::to_string() -> std::string{return R"(/(?as) (\w+) \k{as} (\w+)/)"; } + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_22_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_22_matcher::to_string() -> std::string{return R"(/(?as) (\w+) \k{as} (\w+)/)"; } - - template [[nodiscard]] auto test_tests_11_group_references::regex_23_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_23_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3301,11 +3195,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_23_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_23_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3361,11 +3256,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_23_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_23_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3380,11 +3276,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_23_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_23_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3414,7 +3311,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} std::array str_tmp_5 {" "}; if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { @@ -3440,11 +3337,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_23_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_23_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3470,10 +3368,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_23_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_23_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3481,18 +3380,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_23_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_23_matcher::get_named_group_index(auto const& name) -> int{ if (name == "as") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_23_matcher::to_string() -> std::string{return R"(/(?as) (\w+) \k'as' (\w+)/)"; } - + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_23_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_23_matcher::to_string() -> std::string{return R"(/(?as) (\w+) \k'as' (\w+)/)"; } - template [[nodiscard]] auto test_tests_11_group_references::regex_24_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_24_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3507,11 +3406,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_24_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_24_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3567,11 +3467,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_24_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_24_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3586,11 +3487,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_24_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_24_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3620,7 +3522,7 @@ int i{0}; } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} std::array str_tmp_5 {" "}; if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { @@ -3646,11 +3548,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_24_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_24_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3676,10 +3579,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_24_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_11_group_references::regex_24_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3687,14 +3591,15 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_11_group_references::regex_24_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_11_group_references::regex_24_matcher::get_named_group_index(auto const& name) -> int{ if (name == "as") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_11_group_references::regex_24_matcher::to_string() -> std::string{return R"(/(?as) (\w+) \k{ as } (\w+)/)"; } + template [[nodiscard]] constexpr auto test_tests_11_group_references::regex_24_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_11_group_references::regex_24_matcher::to_string() -> std::string{return R"(/(?as) (\w+) \k{ as } (\w+)/)"; } -#line 219 "pure2-regex_11_group_references.cpp2" +#line 220 "pure2-regex_11_group_references.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_11_group_references()); } diff --git a/regression-tests/test-results/pure2-regex_12_case_insensitive.cpp b/regression-tests/test-results/pure2-regex_12_case_insensitive.cpp index 66b0183cbb..aab6c52a49 100644 --- a/regression-tests/test-results/pure2-regex_12_case_insensitive.cpp +++ b/regression-tests/test-results/pure2-regex_12_case_insensitive.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_12_case_insensitive.cpp2" -#line 165 "pure2-regex_12_case_insensitive.cpp2" +#line 166 "pure2-regex_12_case_insensitive.cpp2" class test_tests_12_case_insensitive; @@ -18,37 +18,31 @@ class test_tests_12_case_insensitive; #line 1 "pure2-regex_12_case_insensitive.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_12_case_insensitive.cpp2" +#line 113 "pure2-regex_12_case_insensitive.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_12_case_insensitive.cpp2" +#line 125 "pure2-regex_12_case_insensitive.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_12_case_insensitive.cpp2" +#line 166 "pure2-regex_12_case_insensitive.cpp2" class test_tests_12_case_insensitive { -#line 285 "pure2-regex_12_case_insensitive.cpp2" +#line 286 "pure2-regex_12_case_insensitive.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -56,25 +50,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -82,25 +70,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_02 {}; public: class regex_03_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_03_matcher() = default; public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -108,25 +90,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_03 {}; public: class regex_04_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_04_matcher() = default; public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -134,25 +110,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_04 {}; public: class regex_05_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_05_matcher() = default; public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -160,25 +130,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_05 {}; public: class regex_06_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_06_matcher() = default; public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -186,35 +150,29 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_06 {}; public: class regex_07_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_06 {}; public: template class regex_07_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_07_matcher() = default; public: regex_07_matcher(regex_07_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -222,35 +180,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_07 {}; public: class regex_08_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_07 {}; public: template class regex_08_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_08_matcher() = default; public: regex_08_matcher(regex_08_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -258,35 +210,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_08 {}; public: class regex_09_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_08 {}; public: template class regex_09_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_09_matcher() = default; public: regex_09_matcher(regex_09_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -294,35 +240,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_09 {}; public: class regex_10_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_09 {}; public: template class regex_10_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_10_matcher() = default; public: regex_10_matcher(regex_10_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -330,35 +270,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_10 {}; public: class regex_100_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_10 {}; public: template class regex_100_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_100_matcher() = default; public: regex_100_matcher(regex_100_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -366,36 +300,35 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_100 {}; public: class regex_101_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_100 {}; public: template class regex_101_matcher { + public: template using context = cpp2::regex::match_context; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -405,31 +338,26 @@ public: class func_3 { }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_101_matcher() = default; public: regex_101_matcher(regex_101_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -437,66 +365,65 @@ public: class func_3 { }; - public: cpp2::regex::regular_expression regex_101 {}; public: class regex_102_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_101 {}; public: template class regex_102_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_10 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_11 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_9 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_12 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -506,26 +433,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_13 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_102_matcher() = default; public: regex_102_matcher(regex_102_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -533,66 +455,65 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_102 {}; public: class regex_103_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_102 {}; public: template class regex_103_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_10 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_11 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_9 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_12 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -602,26 +523,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_13 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_103_matcher() = default; public: regex_103_matcher(regex_103_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -629,66 +545,65 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_103 {}; public: class regex_104_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_103 {}; public: template class regex_104_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_10 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_11 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_9 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_12 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -698,26 +613,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_13 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_104_matcher() = default; public: regex_104_matcher(regex_104_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -725,66 +635,65 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_104 {}; public: class regex_105_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_104 {}; public: template class regex_105_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_10 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_11 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_9 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_12 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -794,26 +703,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_13 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_105_matcher() = default; public: regex_105_matcher(regex_105_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -821,66 +725,65 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_105 {}; public: class regex_106_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_105 {}; public: template class regex_106_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_10 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_11 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_9 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_12 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -890,26 +793,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_13 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_106_matcher() = default; public: regex_106_matcher(regex_106_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -917,25 +815,19 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_106 {}; public: class regex_107_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_106 {}; public: template class regex_107_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_107_matcher() = default; public: regex_107_matcher(regex_107_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -943,25 +835,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_107 {}; public: class regex_108_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_107 {}; public: template class regex_108_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_108_matcher() = default; public: regex_108_matcher(regex_108_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -969,25 +855,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_108 {}; public: class regex_109_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_108 {}; public: template class regex_109_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_109_matcher() = default; public: regex_109_matcher(regex_109_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -995,35 +875,29 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_109 {}; public: class regex_11_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_109 {}; public: template class regex_11_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_11_matcher() = default; public: regex_11_matcher(regex_11_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1031,25 +905,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_11 {}; public: class regex_110_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_11 {}; public: template class regex_110_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_110_matcher() = default; public: regex_110_matcher(regex_110_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1057,25 +925,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_110 {}; public: class regex_111_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_110 {}; public: template class regex_111_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_111_matcher() = default; public: regex_111_matcher(regex_111_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1083,45 +945,39 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_111 {}; public: class regex_112_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_111 {}; public: template class regex_112_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_112_matcher() = default; public: regex_112_matcher(regex_112_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1129,45 +985,39 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_112 {}; public: class regex_113_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_112 {}; public: template class regex_113_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_113_matcher() = default; public: regex_113_matcher(regex_113_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1175,25 +1025,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_113 {}; public: class regex_114_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_113 {}; public: template class regex_114_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_114_matcher() = default; public: regex_114_matcher(regex_114_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1201,25 +1045,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_114 {}; public: class regex_115_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_114 {}; public: template class regex_115_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_115_matcher() = default; public: regex_115_matcher(regex_115_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1227,25 +1065,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_115 {}; public: class regex_116_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_115 {}; public: template class regex_116_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_116_matcher() = default; public: regex_116_matcher(regex_116_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1253,35 +1085,29 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_116 {}; public: class regex_117_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_116 {}; public: template class regex_117_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_117_matcher() = default; public: regex_117_matcher(regex_117_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1289,25 +1115,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_117 {}; public: class regex_118_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_117 {}; public: template class regex_118_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_118_matcher() = default; public: regex_118_matcher(regex_118_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1315,35 +1135,29 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_118 {}; public: class regex_119_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_118 {}; public: template class regex_119_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_119_matcher() = default; public: regex_119_matcher(regex_119_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1351,35 +1165,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_119 {}; public: class regex_12_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_119 {}; public: template class regex_12_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_12_matcher() = default; public: regex_12_matcher(regex_12_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1387,35 +1195,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_12 {}; public: class regex_13_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_12 {}; public: template class regex_13_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_13_matcher() = default; public: regex_13_matcher(regex_13_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1423,35 +1225,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_13 {}; public: class regex_14_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_13 {}; public: template class regex_14_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_14_matcher() = default; public: regex_14_matcher(regex_14_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1459,35 +1255,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_14 {}; public: class regex_15_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_14 {}; public: template class regex_15_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_15_matcher() = default; public: regex_15_matcher(regex_15_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1495,35 +1285,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_15 {}; public: class regex_16_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_15 {}; public: template class regex_16_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_16_matcher() = default; public: regex_16_matcher(regex_16_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1531,35 +1315,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_16 {}; public: class regex_17_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_16 {}; public: template class regex_17_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_17_matcher() = default; public: regex_17_matcher(regex_17_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1567,35 +1345,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_17 {}; public: class regex_18_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_17 {}; public: template class regex_18_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_18_matcher() = default; public: regex_18_matcher(regex_18_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1603,35 +1375,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_18 {}; public: class regex_19_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_18 {}; public: template class regex_19_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_19_matcher() = default; public: regex_19_matcher(regex_19_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1639,35 +1405,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_19 {}; public: class regex_20_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_19 {}; public: template class regex_20_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_20_matcher() = default; public: regex_20_matcher(regex_20_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1675,35 +1435,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_20 {}; public: class regex_21_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_20 {}; public: template class regex_21_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_21_matcher() = default; public: regex_21_matcher(regex_21_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1711,35 +1465,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_21 {}; public: class regex_22_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_21 {}; public: template class regex_22_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_22_matcher() = default; public: regex_22_matcher(regex_22_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1747,35 +1495,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_22 {}; public: class regex_23_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_22 {}; public: template class regex_23_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_23_matcher() = default; public: regex_23_matcher(regex_23_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1783,35 +1525,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_23 {}; public: class regex_24_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_23 {}; public: template class regex_24_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_24_matcher() = default; public: regex_24_matcher(regex_24_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1819,35 +1555,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_24 {}; public: class regex_25_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_24 {}; public: template class regex_25_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_25_matcher() = default; public: regex_25_matcher(regex_25_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1855,35 +1585,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_25 {}; public: class regex_26_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_25 {}; public: template class regex_26_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_26_matcher() = default; public: regex_26_matcher(regex_26_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1891,25 +1615,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_26 {}; public: class regex_27_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_26 {}; public: template class regex_27_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_27_matcher() = default; public: regex_27_matcher(regex_27_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1917,25 +1635,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_27 {}; public: class regex_28_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_27 {}; public: template class regex_28_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_28_matcher() = default; public: regex_28_matcher(regex_28_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1943,25 +1655,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_28 {}; public: class regex_29_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_28 {}; public: template class regex_29_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_29_matcher() = default; public: regex_29_matcher(regex_29_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1969,25 +1675,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_29 {}; public: class regex_30_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_29 {}; public: template class regex_30_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_30_matcher() = default; public: regex_30_matcher(regex_30_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1995,25 +1695,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_30 {}; public: class regex_31_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_30 {}; public: template class regex_31_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_31_matcher() = default; public: regex_31_matcher(regex_31_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2021,25 +1715,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_31 {}; public: class regex_32_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_31 {}; public: template class regex_32_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_32_matcher() = default; public: regex_32_matcher(regex_32_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2047,25 +1735,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_32 {}; public: class regex_33_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_32 {}; public: template class regex_33_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_33_matcher() = default; public: regex_33_matcher(regex_33_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2073,25 +1755,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_33 {}; public: class regex_34_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_33 {}; public: template class regex_34_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_34_matcher() = default; public: regex_34_matcher(regex_34_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2099,25 +1775,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_34 {}; public: class regex_35_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_34 {}; public: template class regex_35_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_35_matcher() = default; public: regex_35_matcher(regex_35_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2125,25 +1795,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_35 {}; public: class regex_36_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_35 {}; public: template class regex_36_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_36_matcher() = default; public: regex_36_matcher(regex_36_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2151,35 +1815,29 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_36 {}; public: class regex_37_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_36 {}; public: template class regex_37_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_37_matcher() = default; public: regex_37_matcher(regex_37_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2187,35 +1845,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_37 {}; public: class regex_38_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_37 {}; public: template class regex_38_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_38_matcher() = default; public: regex_38_matcher(regex_38_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2223,25 +1875,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_38 {}; public: class regex_39_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_38 {}; public: template class regex_39_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_39_matcher() = default; public: regex_39_matcher(regex_39_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2249,25 +1895,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_39 {}; public: class regex_40_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_39 {}; public: template class regex_40_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_40_matcher() = default; public: regex_40_matcher(regex_40_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2275,25 +1915,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_40 {}; public: class regex_41_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_40 {}; public: template class regex_41_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_41_matcher() = default; public: regex_41_matcher(regex_41_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2301,25 +1935,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_41 {}; public: class regex_42_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_41 {}; public: template class regex_42_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_42_matcher() = default; public: regex_42_matcher(regex_42_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2327,25 +1955,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_42 {}; public: class regex_43_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_42 {}; public: template class regex_43_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_43_matcher() = default; public: regex_43_matcher(regex_43_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2353,25 +1975,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_43 {}; public: class regex_44_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_43 {}; public: template class regex_44_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_44_matcher() = default; public: regex_44_matcher(regex_44_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2379,25 +1995,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_44 {}; public: class regex_45_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_44 {}; public: template class regex_45_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_45_matcher() = default; public: regex_45_matcher(regex_45_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2405,25 +2015,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_45 {}; public: class regex_46_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_45 {}; public: template class regex_46_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_46_matcher() = default; public: regex_46_matcher(regex_46_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2431,25 +2035,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_46 {}; public: class regex_47_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_46 {}; public: template class regex_47_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_47_matcher() = default; public: regex_47_matcher(regex_47_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2457,25 +2055,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_47 {}; public: class regex_48_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_47 {}; public: template class regex_48_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_48_matcher() = default; public: regex_48_matcher(regex_48_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2483,25 +2075,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_48 {}; public: class regex_49_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_48 {}; public: template class regex_49_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_49_matcher() = default; public: regex_49_matcher(regex_49_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2509,25 +2095,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_49 {}; public: class regex_50_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_49 {}; public: template class regex_50_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_50_matcher() = default; public: regex_50_matcher(regex_50_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2535,25 +2115,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_50 {}; public: class regex_51_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_50 {}; public: template class regex_51_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_51_matcher() = default; public: regex_51_matcher(regex_51_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2561,25 +2135,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_51 {}; public: class regex_52_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_51 {}; public: template class regex_52_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_52_matcher() = default; public: regex_52_matcher(regex_52_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2587,25 +2155,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_52 {}; public: class regex_53_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_52 {}; public: template class regex_53_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_53_matcher() = default; public: regex_53_matcher(regex_53_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2613,40 +2175,34 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_53 {}; public: class regex_54_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_53 {}; public: template class regex_54_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_54_matcher() = default; public: regex_54_matcher(regex_54_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2654,40 +2210,34 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_54 {}; public: class regex_55_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_54 {}; public: template class regex_55_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_55_matcher() = default; public: regex_55_matcher(regex_55_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2695,25 +2245,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_55 {}; public: class regex_56_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_55 {}; public: template class regex_56_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_56_matcher() = default; public: regex_56_matcher(regex_56_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2721,25 +2265,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_56 {}; public: class regex_57_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_56 {}; public: template class regex_57_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_57_matcher() = default; public: regex_57_matcher(regex_57_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2747,25 +2285,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_57 {}; public: class regex_58_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_57 {}; public: template class regex_58_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_58_matcher() = default; public: regex_58_matcher(regex_58_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2773,35 +2305,29 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_58 {}; public: class regex_59_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_58 {}; public: template class regex_59_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_59_matcher() = default; public: regex_59_matcher(regex_59_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2809,35 +2335,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_59 {}; public: class regex_60_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_59 {}; public: template class regex_60_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_60_matcher() = default; public: regex_60_matcher(regex_60_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2845,25 +2365,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_60 {}; public: class regex_61_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_60 {}; public: template class regex_61_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_61_matcher() = default; public: regex_61_matcher(regex_61_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2871,25 +2385,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_61 {}; public: class regex_62_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_61 {}; public: template class regex_62_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_62_matcher() = default; public: regex_62_matcher(regex_62_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2897,25 +2405,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_62 {}; public: class regex_63_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_62 {}; public: template class regex_63_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_63_matcher() = default; public: regex_63_matcher(regex_63_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2923,45 +2425,39 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_63 {}; public: class regex_64_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_63 {}; public: template class regex_64_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_64_matcher() = default; public: regex_64_matcher(regex_64_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2969,45 +2465,39 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_64 {}; public: class regex_65_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_64 {}; public: template class regex_65_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_65_matcher() = default; public: regex_65_matcher(regex_65_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3015,35 +2505,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_65 {}; public: class regex_66_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_65 {}; public: template class regex_66_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_66_matcher() = default; public: regex_66_matcher(regex_66_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3051,35 +2535,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_66 {}; public: class regex_67_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_66 {}; public: template class regex_67_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_67_matcher() = default; public: regex_67_matcher(regex_67_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3087,35 +2565,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_67 {}; public: class regex_68_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_67 {}; public: template class regex_68_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_68_matcher() = default; public: regex_68_matcher(regex_68_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3123,36 +2595,35 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_68 {}; public: class regex_69_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_68 {}; public: template class regex_69_matcher { + public: template using context = cpp2::regex::match_context; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -3162,26 +2633,21 @@ public: class func_3 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_69_matcher() = default; public: regex_69_matcher(regex_69_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3189,36 +2655,35 @@ public: class func_3 { }; - public: cpp2::regex::regular_expression regex_69 {}; public: class regex_70_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_69 {}; public: template class regex_70_matcher { + public: template using context = cpp2::regex::match_context; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -3228,26 +2693,21 @@ public: class func_3 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_70_matcher() = default; public: regex_70_matcher(regex_70_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3255,36 +2715,35 @@ public: class func_3 { }; - public: cpp2::regex::regular_expression regex_70 {}; public: class regex_71_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_70 {}; public: template class regex_71_matcher { + public: template using context = cpp2::regex::match_context; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -3294,26 +2753,21 @@ public: class func_3 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_71_matcher() = default; public: regex_71_matcher(regex_71_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3321,36 +2775,35 @@ public: class func_3 { }; - public: cpp2::regex::regular_expression regex_71 {}; public: class regex_72_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_71 {}; public: template class regex_72_matcher { + public: template using context = cpp2::regex::match_context; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -3360,26 +2813,21 @@ public: class func_3 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_72_matcher() = default; public: regex_72_matcher(regex_72_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3387,36 +2835,35 @@ public: class func_3 { }; - public: cpp2::regex::regular_expression regex_72 {}; public: class regex_73_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_72 {}; public: template class regex_73_matcher { + public: template using context = cpp2::regex::match_context; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -3426,26 +2873,21 @@ public: class func_3 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_73_matcher() = default; public: regex_73_matcher(regex_73_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3453,36 +2895,35 @@ public: class func_3 { }; - public: cpp2::regex::regular_expression regex_73 {}; public: class regex_74_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_73 {}; public: template class regex_74_matcher { + public: template using context = cpp2::regex::match_context; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -3492,26 +2933,21 @@ public: class func_3 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_74_matcher() = default; public: regex_74_matcher(regex_74_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3519,36 +2955,35 @@ public: class func_3 { }; - public: cpp2::regex::regular_expression regex_74 {}; public: class regex_75_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_74 {}; public: template class regex_75_matcher { + public: template using context = cpp2::regex::match_context; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -3558,26 +2993,21 @@ public: class func_3 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_75_matcher() = default; public: regex_75_matcher(regex_75_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3585,35 +3015,29 @@ public: class func_3 { }; - public: cpp2::regex::regular_expression regex_75 {}; public: class regex_76_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_75 {}; public: template class regex_76_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_76_matcher() = default; public: regex_76_matcher(regex_76_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3621,25 +3045,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_76 {}; public: class regex_77_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_76 {}; public: template class regex_77_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_77_matcher() = default; public: regex_77_matcher(regex_77_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3647,35 +3065,29 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_77 {}; public: class regex_78_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_77 {}; public: template class regex_78_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_78_matcher() = default; public: regex_78_matcher(regex_78_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3683,11 +3095,10 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_78 {}; public: class regex_79_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_78 {}; public: template class regex_79_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -3697,26 +3108,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_79_matcher() = default; public: regex_79_matcher(regex_79_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3724,11 +3130,10 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_79 {}; public: class regex_80_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_79 {}; public: template class regex_80_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -3738,26 +3143,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_80_matcher() = default; public: regex_80_matcher(regex_80_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3765,55 +3165,49 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_80 {}; public: class regex_81_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_80 {}; public: template class regex_81_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_81_matcher() = default; public: regex_81_matcher(regex_81_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3821,55 +3215,49 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_81 {}; public: class regex_82_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_81 {}; public: template class regex_82_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_82_matcher() = default; public: regex_82_matcher(regex_82_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3877,35 +3265,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_82 {}; public: class regex_83_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_82 {}; public: template class regex_83_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_83_matcher() = default; public: regex_83_matcher(regex_83_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3913,35 +3295,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_83 {}; public: class regex_84_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_83 {}; public: template class regex_84_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_84_matcher() = default; public: regex_84_matcher(regex_84_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3949,35 +3325,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_84 {}; public: class regex_85_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_84 {}; public: template class regex_85_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_85_matcher() = default; public: regex_85_matcher(regex_85_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3985,40 +3355,34 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_85 {}; public: class regex_86_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_85 {}; public: template class regex_86_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_86_matcher() = default; public: regex_86_matcher(regex_86_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4026,25 +3390,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_86 {}; public: class regex_87_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_86 {}; public: template class regex_87_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_87_matcher() = default; public: regex_87_matcher(regex_87_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4052,40 +3410,34 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_87 {}; public: class regex_88_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_87 {}; public: template class regex_88_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_88_matcher() = default; public: regex_88_matcher(regex_88_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4093,40 +3445,34 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_88 {}; public: class regex_89_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_88 {}; public: template class regex_89_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_89_matcher() = default; public: regex_89_matcher(regex_89_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4134,50 +3480,44 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_89 {}; public: class regex_90_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_89 {}; public: template class regex_90_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_90_matcher() = default; public: regex_90_matcher(regex_90_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4185,50 +3525,44 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_90 {}; public: class regex_91_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_90 {}; public: template class regex_91_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_91_matcher() = default; public: regex_91_matcher(regex_91_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4236,45 +3570,39 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_91 {}; public: class regex_92_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_91 {}; public: template class regex_92_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_92_matcher() = default; public: regex_92_matcher(regex_92_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4282,45 +3610,39 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_92 {}; public: class regex_93_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_92 {}; public: template class regex_93_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_93_matcher() = default; public: regex_93_matcher(regex_93_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4328,45 +3650,39 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_93 {}; public: class regex_94_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_93 {}; public: template class regex_94_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_94_matcher() = default; public: regex_94_matcher(regex_94_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4374,45 +3690,39 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_94 {}; public: class regex_95_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_94 {}; public: template class regex_95_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_95_matcher() = default; public: regex_95_matcher(regex_95_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4420,35 +3730,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_95 {}; public: class regex_96_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_95 {}; public: template class regex_96_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_96_matcher() = default; public: regex_96_matcher(regex_96_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4456,35 +3760,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_96 {}; public: class regex_97_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_96 {}; public: template class regex_97_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_97_matcher() = default; public: regex_97_matcher(regex_97_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4492,50 +3790,44 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_97 {}; public: class regex_98_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_97 {}; public: template class regex_98_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_98_matcher() = default; public: regex_98_matcher(regex_98_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4543,25 +3835,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_98 {}; public: class regex_99_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_98 {}; public: template class regex_99_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_99_matcher() = default; public: regex_99_matcher(regex_99_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4569,13 +3855,13 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_99 {}; + public: cpp2::regex::regular_expression> regex_99 {}; public: test_tests_12_case_insensitive() = default; public: test_tests_12_case_insensitive(test_tests_12_case_insensitive const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_12_case_insensitive const&) -> void = delete; -#line 408 "pure2-regex_12_case_insensitive.cpp2" +#line 409 "pure2-regex_12_case_insensitive.cpp2" }; auto main() -> int; @@ -4679,6 +3965,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -4694,7 +3981,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_12_case_insensitive.cpp2" +#line 113 "pure2-regex_12_case_insensitive.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -4707,7 +3994,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_12_case_insensitive.cpp2" +#line 125 "pure2-regex_12_case_insensitive.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -4748,7 +4035,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 285 "pure2-regex_12_case_insensitive.cpp2" +#line 286 "pure2-regex_12_case_insensitive.cpp2" auto test_tests_12_case_insensitive::run() const& -> void{ std::cout << "Running tests_12_case_insensitive:" << std::endl; test(regex_01, "01", R"('abc'i)", "ABC", "y", R"($&)", "ABC"); @@ -4876,8 +4163,7 @@ template auto test(M const& regex, cpp2::impl::in id, c - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4907,10 +4193,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4918,19 +4205,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_01_matcher::to_string() -> std::string{return R"('abc'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_01_matcher::to_string() -> std::string{return R"('abc'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4960,10 +4247,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4971,19 +4259,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_02_matcher::to_string() -> std::string{return R"('abc'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_02_matcher::to_string() -> std::string{return R"('abc'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_03_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5013,10 +4301,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_03_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5024,19 +4313,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_03_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_03_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_03_matcher::to_string() -> std::string{return R"('abc'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_03_matcher::to_string() -> std::string{return R"('abc'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_04_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5066,10 +4355,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_04_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5077,19 +4367,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_04_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_04_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_04_matcher::to_string() -> std::string{return R"('abc'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_04_matcher::to_string() -> std::string{return R"('abc'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_05_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5119,10 +4409,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_05_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5130,19 +4421,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_05_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_05_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_05_matcher::to_string() -> std::string{return R"('abc'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_05_matcher::to_string() -> std::string{return R"('abc'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_06_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5172,10 +4463,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_06_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5183,19 +4475,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_06_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_06_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_06_matcher::to_string() -> std::string{return R"('abc'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_06_matcher::to_string() -> std::string{return R"('abc'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_07_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_07_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5225,11 +4517,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_07_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_07_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5259,11 +4552,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_07_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_07_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5293,10 +4587,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_07_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_07_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5304,19 +4599,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_07_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_07_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_07_matcher::to_string() -> std::string{return R"('ab*c'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_07_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_07_matcher::to_string() -> std::string{return R"('ab*c'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_08_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_08_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5346,11 +4641,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_08_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_08_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5380,11 +4676,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_08_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_08_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5414,10 +4711,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_08_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_08_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5425,19 +4723,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_08_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_08_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_08_matcher::to_string() -> std::string{return R"('ab*bc'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_08_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_08_matcher::to_string() -> std::string{return R"('ab*bc'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_09_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_09_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5467,11 +4765,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_09_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_09_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5501,11 +4800,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_09_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_09_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5535,10 +4835,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_09_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_09_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5546,19 +4847,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_09_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_09_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_09_matcher::to_string() -> std::string{return R"('ab*bc'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_09_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_09_matcher::to_string() -> std::string{return R"('ab*bc'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_10_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_10_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5588,11 +4889,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_10_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_10_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5622,11 +4924,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_10_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_10_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5656,10 +4959,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_10_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_10_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5667,19 +4971,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_10_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_10_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_10_matcher::to_string() -> std::string{return R"('ab*?bc'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_10_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_10_matcher::to_string() -> std::string{return R"('ab*?bc'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_100_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_100_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5694,11 +4998,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_100_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_100_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5713,11 +5018,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_100_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_100_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5731,10 +5037,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_100_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_100_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5742,19 +5049,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_100_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_100_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_100_matcher::to_string() -> std::string{return R"('[a-zA-Z_][a-zA-Z0-9_]*'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_100_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_100_matcher::to_string() -> std::string{return R"('[a-zA-Z_][a-zA-Z0-9_]*'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5784,11 +5091,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5818,11 +5126,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5836,11 +5145,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5871,11 +5181,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5907,11 +5218,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5953,16 +5265,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_12_case_insensitive::regex_101_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_12_case_insensitive::regex_101_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5994,11 +5307,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6012,11 +5326,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6030,10 +5345,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6041,19 +5357,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::to_string() -> std::string{return R"('^a(bc+|b[eh])g|.h$'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_101_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_101_matcher::to_string() -> std::string{return R"('^a(bc+|b[eh])g|.h$'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6083,11 +5399,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6117,11 +5434,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6152,11 +5470,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6186,11 +5505,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6220,11 +5540,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6255,11 +5576,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6289,11 +5611,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6307,11 +5630,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::wrap::func_10::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::func_10::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6341,11 +5665,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::wrap::func_11::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::func_11::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6375,11 +5700,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::wrap::func_9::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::func_9::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6410,11 +5736,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::wrap::func_12::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::func_12::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6440,16 +5767,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_12_case_insensitive::regex_102_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_12_case_insensitive::regex_102_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(2); } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6464,11 +5792,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::wrap::func_13::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::func_13::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6494,10 +5823,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6505,19 +5835,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::to_string() -> std::string{return R"('(bc+d$|ef*g.|h?i(j|k))'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_102_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_102_matcher::to_string() -> std::string{return R"('(bc+d$|ef*g.|h?i(j|k))'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6547,11 +5877,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6581,11 +5912,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6616,11 +5948,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6650,11 +5983,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6684,11 +6018,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6719,11 +6054,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6753,11 +6089,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6771,11 +6108,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::wrap::func_10::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::func_10::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6805,11 +6143,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::wrap::func_11::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::func_11::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6839,11 +6178,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::wrap::func_9::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::func_9::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6874,11 +6214,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::wrap::func_12::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::func_12::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6904,16 +6245,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_12_case_insensitive::regex_103_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_12_case_insensitive::regex_103_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(2); } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6928,11 +6270,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::wrap::func_13::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::func_13::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6958,10 +6301,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6969,19 +6313,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::to_string() -> std::string{return R"('(bc+d$|ef*g.|h?i(j|k))'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_103_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_103_matcher::to_string() -> std::string{return R"('(bc+d$|ef*g.|h?i(j|k))'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7011,11 +6355,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7045,11 +6390,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7080,11 +6426,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7114,11 +6461,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7148,11 +6496,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7183,11 +6532,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7217,11 +6567,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7235,11 +6586,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::wrap::func_10::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::func_10::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7269,11 +6621,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::wrap::func_11::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::func_11::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7303,11 +6656,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::wrap::func_9::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::func_9::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7338,11 +6692,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::wrap::func_12::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::func_12::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7368,16 +6723,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_12_case_insensitive::regex_104_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_12_case_insensitive::regex_104_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(2); } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7392,11 +6748,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::wrap::func_13::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::func_13::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7422,10 +6779,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7433,19 +6791,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::to_string() -> std::string{return R"('(bc+d$|ef*g.|h?i(j|k))'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_104_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_104_matcher::to_string() -> std::string{return R"('(bc+d$|ef*g.|h?i(j|k))'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7475,11 +6833,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7509,11 +6868,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7544,11 +6904,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7578,11 +6939,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7612,11 +6974,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7647,11 +7010,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7681,11 +7045,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7699,11 +7064,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::wrap::func_10::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::func_10::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7733,11 +7099,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::wrap::func_11::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::func_11::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7767,11 +7134,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::wrap::func_9::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::func_9::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7802,11 +7170,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::wrap::func_12::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::func_12::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7832,16 +7201,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_12_case_insensitive::regex_105_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_12_case_insensitive::regex_105_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(2); } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7856,11 +7226,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::wrap::func_13::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::func_13::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7886,10 +7257,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7897,19 +7269,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::to_string() -> std::string{return R"('(bc+d$|ef*g.|h?i(j|k))'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_105_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_105_matcher::to_string() -> std::string{return R"('(bc+d$|ef*g.|h?i(j|k))'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7939,11 +7311,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7973,11 +7346,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8008,11 +7382,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8042,11 +7417,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8076,11 +7452,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8111,11 +7488,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8145,11 +7523,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8163,11 +7542,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::wrap::func_10::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::func_10::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8197,11 +7577,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::wrap::func_11::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::func_11::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8231,11 +7612,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::wrap::func_9::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::func_9::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8266,11 +7648,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::wrap::func_12::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::func_12::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8296,16 +7679,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_12_case_insensitive::regex_106_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_12_case_insensitive::regex_106_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(2); } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8320,11 +7704,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::wrap::func_13::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::func_13::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8350,10 +7735,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8361,19 +7747,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::to_string() -> std::string{return R"('(bc+d$|ef*g.|h?i(j|k))'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_106_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_106_matcher::to_string() -> std::string{return R"('(bc+d$|ef*g.|h?i(j|k))'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_107_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_107_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8533,10 +7919,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_107_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_107_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8544,19 +7931,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_107_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_107_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_107_matcher::to_string() -> std::string{return R"('((((((((((a))))))))))'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_107_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_107_matcher::to_string() -> std::string{return R"('((((((((((a))))))))))'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_108_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_108_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8706,7 +8093,7 @@ int i{0}; auto tmp_10 {cpp2::regex::make_on_return(cpp2::move(tmp_10_func))}; static_cast(cpp2::move(tmp_10)); - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -8717,10 +8104,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_108_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_108_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8728,19 +8116,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_108_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_108_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_108_matcher::to_string() -> std::string{return R"('((((((((((a))))))))))\10'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_108_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_108_matcher::to_string() -> std::string{return R"('((((((((((a))))))))))\10'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_109_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_109_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8887,10 +8275,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_109_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_109_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8898,19 +8287,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_109_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_109_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_109_matcher::to_string() -> std::string{return R"('(((((((((a)))))))))'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_109_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_109_matcher::to_string() -> std::string{return R"('(((((((((a)))))))))'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_11_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_11_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8940,11 +8329,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_11_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_11_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8974,11 +8364,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_11_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_11_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9008,10 +8399,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_11_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_11_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9019,19 +8411,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_11_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_11_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_11_matcher::to_string() -> std::string{return R"('ab{0,}?bc'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_11_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_11_matcher::to_string() -> std::string{return R"('ab{0,}?bc'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_110_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_110_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9061,10 +8453,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_110_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_110_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9072,19 +8465,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_110_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_110_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_110_matcher::to_string() -> std::string{return R"('multiple words of text'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_110_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_110_matcher::to_string() -> std::string{return R"('multiple words of text'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_111_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_111_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9114,10 +8507,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_111_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_111_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9125,19 +8519,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_111_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_111_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_111_matcher::to_string() -> std::string{return R"('multiple words'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_111_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_111_matcher::to_string() -> std::string{return R"('multiple words'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_112_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_112_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9152,11 +8546,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_112_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_112_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9171,11 +8566,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_112_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_112_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9190,11 +8586,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_112_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_112_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9237,11 +8634,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_112_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_112_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9267,10 +8665,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_112_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_112_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9278,19 +8677,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_112_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_112_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_112_matcher::to_string() -> std::string{return R"('(.*)c(.*)'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_112_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_112_matcher::to_string() -> std::string{return R"('(.*)c(.*)'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_113_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_113_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9305,11 +8704,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_113_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_113_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9338,11 +8738,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_113_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_113_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9357,11 +8758,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_113_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_113_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9402,11 +8804,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_113_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_113_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9446,10 +8849,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_113_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_113_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9457,19 +8861,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_113_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_113_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_113_matcher::to_string() -> std::string{return R"('\((.*), (.*)\)'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_113_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_113_matcher::to_string() -> std::string{return R"('\((.*), (.*)\)'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_114_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_114_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9484,10 +8888,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_114_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_114_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9495,19 +8900,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_114_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_114_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_114_matcher::to_string() -> std::string{return R"('[k]'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_114_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_114_matcher::to_string() -> std::string{return R"('[k]'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_115_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_115_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9537,10 +8942,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_115_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_115_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9548,19 +8954,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_115_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_115_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_115_matcher::to_string() -> std::string{return R"('abcd'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_115_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_115_matcher::to_string() -> std::string{return R"('abcd'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_116_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_116_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9635,10 +9041,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_116_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_116_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9646,19 +9053,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_116_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_116_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_116_matcher::to_string() -> std::string{return R"('a(bc)d'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_116_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_116_matcher::to_string() -> std::string{return R"('a(bc)d'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_117_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_117_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9673,11 +9080,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_117_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_117_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9707,11 +9115,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_117_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_117_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9741,10 +9150,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_117_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_117_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9752,19 +9162,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_117_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_117_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_117_matcher::to_string() -> std::string{return R"('a[-]?c'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_117_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_117_matcher::to_string() -> std::string{return R"('a[-]?c'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_118_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_118_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9797,7 +9207,7 @@ int i{0}; auto tmp_1 {cpp2::regex::make_on_return(cpp2::move(tmp_1_func))}; static_cast(cpp2::move(tmp_1)); - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -9808,10 +9218,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_118_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_118_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9819,19 +9230,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_118_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_118_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_118_matcher::to_string() -> std::string{return R"('(abc)\1'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_118_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_118_matcher::to_string() -> std::string{return R"('(abc)\1'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_119_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_119_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9846,11 +9257,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_119_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_119_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9865,11 +9277,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_119_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_119_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9885,7 +9298,7 @@ int i{0}; auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; static_cast(cpp2::move(tmp_0)); - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -9896,10 +9309,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_119_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_119_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9907,19 +9321,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_119_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_119_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_119_matcher::to_string() -> std::string{return R"('([a-c]*)\1'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_119_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_119_matcher::to_string() -> std::string{return R"('([a-c]*)\1'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_12_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_12_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9949,11 +9363,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_12_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_12_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9983,11 +9398,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_12_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_12_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10017,10 +9433,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_12_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_12_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10028,19 +9445,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_12_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_12_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_12_matcher::to_string() -> std::string{return R"('ab+?bc'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_12_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_12_matcher::to_string() -> std::string{return R"('ab+?bc'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_13_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_13_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10070,11 +9487,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_13_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_13_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10104,11 +9522,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_13_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_13_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10138,10 +9557,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_13_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_13_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10149,19 +9569,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_13_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_13_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_13_matcher::to_string() -> std::string{return R"('ab+bc'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_13_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_13_matcher::to_string() -> std::string{return R"('ab+bc'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_14_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_14_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10191,11 +9611,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_14_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_14_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10225,11 +9646,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_14_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_14_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10259,10 +9681,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_14_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_14_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10270,19 +9693,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_14_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_14_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_14_matcher::to_string() -> std::string{return R"('ab+bc'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_14_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_14_matcher::to_string() -> std::string{return R"('ab+bc'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_15_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_15_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10312,11 +9735,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_15_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_15_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10346,11 +9770,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_15_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_15_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10380,10 +9805,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_15_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_15_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10391,19 +9817,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_15_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_15_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_15_matcher::to_string() -> std::string{return R"('ab{1,}bc'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_15_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_15_matcher::to_string() -> std::string{return R"('ab{1,}bc'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_16_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_16_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10433,11 +9859,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_16_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_16_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10467,11 +9894,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_16_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_16_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10501,10 +9929,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_16_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_16_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10512,19 +9941,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_16_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_16_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_16_matcher::to_string() -> std::string{return R"('ab+bc'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_16_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_16_matcher::to_string() -> std::string{return R"('ab+bc'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_17_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_17_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10554,11 +9983,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_17_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_17_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10588,11 +10018,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_17_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_17_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10622,10 +10053,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_17_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_17_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10633,19 +10065,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_17_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_17_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_17_matcher::to_string() -> std::string{return R"('ab{1,}?bc'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_17_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_17_matcher::to_string() -> std::string{return R"('ab{1,}?bc'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_18_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_18_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10675,11 +10107,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_18_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_18_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10709,11 +10142,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_18_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_18_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10743,10 +10177,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_18_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_18_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10754,19 +10189,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_18_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_18_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_18_matcher::to_string() -> std::string{return R"('ab{1,3}?bc'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_18_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_18_matcher::to_string() -> std::string{return R"('ab{1,3}?bc'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_19_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_19_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10796,11 +10231,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_19_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_19_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10830,11 +10266,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_19_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_19_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10864,10 +10301,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_19_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_19_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10875,19 +10313,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_19_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_19_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_19_matcher::to_string() -> std::string{return R"('ab{3,4}?bc'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_19_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_19_matcher::to_string() -> std::string{return R"('ab{3,4}?bc'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_20_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_20_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10917,11 +10355,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_20_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_20_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10951,11 +10390,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_20_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_20_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10985,10 +10425,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_20_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_20_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10996,19 +10437,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_20_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_20_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_20_matcher::to_string() -> std::string{return R"('ab{4,5}?bc'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_20_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_20_matcher::to_string() -> std::string{return R"('ab{4,5}?bc'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_21_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_21_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11038,11 +10479,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_21_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_21_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11072,11 +10514,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_21_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_21_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11106,10 +10549,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_21_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_21_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11117,19 +10561,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_21_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_21_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_21_matcher::to_string() -> std::string{return R"('ab??bc'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_21_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_21_matcher::to_string() -> std::string{return R"('ab??bc'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_22_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_22_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11159,11 +10603,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_22_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_22_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11193,11 +10638,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_22_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_22_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11227,10 +10673,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_22_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_22_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11238,19 +10685,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_22_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_22_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_22_matcher::to_string() -> std::string{return R"('ab??bc'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_22_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_22_matcher::to_string() -> std::string{return R"('ab??bc'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_23_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_23_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11280,11 +10727,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_23_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_23_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11314,11 +10762,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_23_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_23_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11348,10 +10797,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_23_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_23_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11359,19 +10809,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_23_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_23_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_23_matcher::to_string() -> std::string{return R"('ab{0,1}?bc'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_23_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_23_matcher::to_string() -> std::string{return R"('ab{0,1}?bc'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_24_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_24_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11401,11 +10851,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_24_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_24_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11435,11 +10886,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_24_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_24_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11469,10 +10921,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_24_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_24_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11480,19 +10933,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_24_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_24_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_24_matcher::to_string() -> std::string{return R"('ab??bc'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_24_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_24_matcher::to_string() -> std::string{return R"('ab??bc'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_25_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_25_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11522,11 +10975,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_25_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_25_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11556,11 +11010,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_25_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_25_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11590,10 +11045,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_25_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_25_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11601,19 +11057,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_25_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_25_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_25_matcher::to_string() -> std::string{return R"('ab??c'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_25_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_25_matcher::to_string() -> std::string{return R"('ab??c'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_26_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_26_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11643,11 +11099,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_26_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_26_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11677,11 +11134,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_26_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_26_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11711,10 +11169,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_26_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_26_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11722,19 +11181,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_26_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_26_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_26_matcher::to_string() -> std::string{return R"('ab{0,1}?c'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_26_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_26_matcher::to_string() -> std::string{return R"('ab{0,1}?c'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_27_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_27_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11766,10 +11225,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_27_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_27_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11777,19 +11237,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_27_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_27_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_27_matcher::to_string() -> std::string{return R"('^abc$'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_27_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_27_matcher::to_string() -> std::string{return R"('^abc$'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_28_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_28_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11821,10 +11281,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_28_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_28_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11832,19 +11293,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_28_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_28_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_28_matcher::to_string() -> std::string{return R"('^abc$'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_28_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_28_matcher::to_string() -> std::string{return R"('^abc$'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_29_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_29_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11875,10 +11336,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_29_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_29_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11886,19 +11348,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_29_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_29_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_29_matcher::to_string() -> std::string{return R"('^abc'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_29_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_29_matcher::to_string() -> std::string{return R"('^abc'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_30_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_30_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11930,10 +11392,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_30_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_30_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11941,19 +11404,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_30_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_30_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_30_matcher::to_string() -> std::string{return R"('^abc$'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_30_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_30_matcher::to_string() -> std::string{return R"('^abc$'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_31_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_31_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11984,10 +11447,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_31_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_31_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11995,19 +11459,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_31_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_31_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_31_matcher::to_string() -> std::string{return R"('abc$'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_31_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_31_matcher::to_string() -> std::string{return R"('abc$'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_32_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_32_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12022,10 +11486,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_32_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_32_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12033,19 +11498,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_32_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_32_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_32_matcher::to_string() -> std::string{return R"('^'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_32_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_32_matcher::to_string() -> std::string{return R"('^'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_33_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_33_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12060,10 +11525,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_33_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_33_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12071,19 +11537,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_33_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_33_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_33_matcher::to_string() -> std::string{return R"('$'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_33_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_33_matcher::to_string() -> std::string{return R"('$'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_34_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_34_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12130,10 +11596,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_34_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_34_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12141,19 +11608,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_34_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_34_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_34_matcher::to_string() -> std::string{return R"('a.c'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_34_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_34_matcher::to_string() -> std::string{return R"('a.c'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_35_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_35_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12200,10 +11667,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_35_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_35_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12211,19 +11679,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_35_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_35_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_35_matcher::to_string() -> std::string{return R"('a.c'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_35_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_35_matcher::to_string() -> std::string{return R"('a.c'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_36_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_36_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12270,10 +11738,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_36_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_36_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12281,19 +11750,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_36_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_36_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_36_matcher::to_string() -> std::string{return R"('a\Nc'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_36_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_36_matcher::to_string() -> std::string{return R"('a\Nc'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_37_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_37_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12308,11 +11777,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_37_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_37_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12342,11 +11812,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_37_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_37_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12376,10 +11847,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_37_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_37_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12387,19 +11859,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_37_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_37_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_37_matcher::to_string() -> std::string{return R"('a.*?c'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_37_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_37_matcher::to_string() -> std::string{return R"('a.*?c'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_38_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_38_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12414,11 +11886,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_38_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_38_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12448,11 +11921,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_38_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_38_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12482,10 +11956,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_38_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_38_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12493,19 +11968,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_38_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_38_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_38_matcher::to_string() -> std::string{return R"('a.*c'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_38_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_38_matcher::to_string() -> std::string{return R"('a.*c'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_39_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_39_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12552,10 +12027,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_39_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_39_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12563,19 +12039,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_39_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_39_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_39_matcher::to_string() -> std::string{return R"('a[bc]d'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_39_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_39_matcher::to_string() -> std::string{return R"('a[bc]d'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_40_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_40_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12622,10 +12098,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_40_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_40_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12633,19 +12110,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_40_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_40_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_40_matcher::to_string() -> std::string{return R"('a[bc]d'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_40_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_40_matcher::to_string() -> std::string{return R"('a[bc]d'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_41_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_41_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12692,10 +12169,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_41_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_41_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12703,19 +12181,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_41_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_41_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_41_matcher::to_string() -> std::string{return R"('a[b-d]e'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_41_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_41_matcher::to_string() -> std::string{return R"('a[b-d]e'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_42_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_42_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12762,10 +12240,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_42_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_42_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12773,19 +12252,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_42_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_42_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_42_matcher::to_string() -> std::string{return R"('a[b-d]e'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_42_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_42_matcher::to_string() -> std::string{return R"('a[b-d]e'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_43_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_43_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12816,10 +12295,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_43_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_43_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12827,19 +12307,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_43_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_43_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_43_matcher::to_string() -> std::string{return R"('a[b-d]'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_43_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_43_matcher::to_string() -> std::string{return R"('a[b-d]'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_44_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_44_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12870,10 +12350,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_44_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_44_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12881,19 +12362,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_44_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_44_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_44_matcher::to_string() -> std::string{return R"('a[-b]'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_44_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_44_matcher::to_string() -> std::string{return R"('a[-b]'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_45_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_45_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12924,10 +12405,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_45_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_45_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12935,19 +12417,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_45_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_45_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_45_matcher::to_string() -> std::string{return R"('a[b-]'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_45_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_45_matcher::to_string() -> std::string{return R"('a[b-]'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_46_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_46_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12977,10 +12459,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_46_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_46_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12988,19 +12471,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_46_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_46_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_46_matcher::to_string() -> std::string{return R"('a]'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_46_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_46_matcher::to_string() -> std::string{return R"('a]'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_47_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_47_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13047,10 +12530,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_47_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_47_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13058,19 +12542,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_47_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_47_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_47_matcher::to_string() -> std::string{return R"('a[]]b'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_47_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_47_matcher::to_string() -> std::string{return R"('a[]]b'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_48_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_48_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13117,10 +12601,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_48_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_48_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13128,19 +12613,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_48_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_48_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_48_matcher::to_string() -> std::string{return R"('a[^bc]d'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_48_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_48_matcher::to_string() -> std::string{return R"('a[^bc]d'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_49_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_49_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13187,10 +12672,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_49_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_49_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13198,19 +12684,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_49_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_49_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_49_matcher::to_string() -> std::string{return R"('a[^bc]d'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_49_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_49_matcher::to_string() -> std::string{return R"('a[^bc]d'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_50_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_50_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13257,10 +12743,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_50_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_50_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13268,19 +12755,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_50_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_50_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_50_matcher::to_string() -> std::string{return R"('a[^-b]c'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_50_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_50_matcher::to_string() -> std::string{return R"('a[^-b]c'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_51_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_51_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13327,10 +12814,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_51_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_51_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13338,19 +12826,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_51_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_51_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_51_matcher::to_string() -> std::string{return R"('a[^-b]c'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_51_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_51_matcher::to_string() -> std::string{return R"('a[^-b]c'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_52_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_52_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13397,10 +12885,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_52_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_52_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13408,19 +12897,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_52_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_52_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_52_matcher::to_string() -> std::string{return R"('a[^]b]c'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_52_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_52_matcher::to_string() -> std::string{return R"('a[^]b]c'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_53_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_53_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13467,10 +12956,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_53_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_53_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13478,19 +12968,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_53_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_53_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_53_matcher::to_string() -> std::string{return R"('a[^]b]c'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_53_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_53_matcher::to_string() -> std::string{return R"('a[^]b]c'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_54_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_54_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13520,11 +13010,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_54_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_54_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13554,11 +13045,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_54_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_54_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13572,11 +13064,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_54_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_54_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13590,10 +13083,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_54_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_54_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13601,19 +13095,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_54_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_54_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_54_matcher::to_string() -> std::string{return R"('ab|cd'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_54_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_54_matcher::to_string() -> std::string{return R"('ab|cd'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_55_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_55_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13643,11 +13137,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_55_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_55_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13677,11 +13172,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_55_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_55_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13695,11 +13191,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_55_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_55_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13713,10 +13210,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_55_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_55_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13724,19 +13222,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_55_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_55_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_55_matcher::to_string() -> std::string{return R"('ab|cd'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_55_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_55_matcher::to_string() -> std::string{return R"('ab|cd'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_56_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_56_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13779,10 +13277,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_56_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_56_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13790,19 +13289,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_56_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_56_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_56_matcher::to_string() -> std::string{return R"('()ef'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_56_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_56_matcher::to_string() -> std::string{return R"('()ef'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_57_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_57_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13833,10 +13332,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_57_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_57_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13844,19 +13344,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_57_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_57_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_57_matcher::to_string() -> std::string{return R"('$b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_57_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_57_matcher::to_string() -> std::string{return R"('$b'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_58_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_58_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13886,10 +13386,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_58_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_58_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13897,19 +13398,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_58_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_58_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_58_matcher::to_string() -> std::string{return R"('a\(b'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_58_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_58_matcher::to_string() -> std::string{return R"('a\(b'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_59_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_59_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13937,11 +13438,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_59_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_59_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13971,11 +13473,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_59_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_59_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14005,10 +13508,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_59_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_59_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14016,19 +13520,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_59_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_59_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_59_matcher::to_string() -> std::string{return R"('a\(*b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_59_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_59_matcher::to_string() -> std::string{return R"('a\(*b'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_60_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_60_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14056,11 +13560,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_60_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_60_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14090,11 +13595,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_60_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_60_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14124,10 +13630,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_60_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_60_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14135,19 +13642,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_60_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_60_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_60_matcher::to_string() -> std::string{return R"('a\(*b'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_60_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_60_matcher::to_string() -> std::string{return R"('a\(*b'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_61_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_61_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14177,10 +13684,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_61_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_61_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14188,19 +13696,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_61_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_61_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_61_matcher::to_string() -> std::string{return R"('a\\b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_61_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_61_matcher::to_string() -> std::string{return R"('a\\b'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_62_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_62_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14256,10 +13764,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_62_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_62_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14267,19 +13776,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_62_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_62_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_62_matcher::to_string() -> std::string{return R"('((a))'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_62_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_62_matcher::to_string() -> std::string{return R"('((a))'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_63_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_63_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14367,10 +13876,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_63_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_63_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14378,19 +13888,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_63_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_63_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_63_matcher::to_string() -> std::string{return R"('(a)b(c)'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_63_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_63_matcher::to_string() -> std::string{return R"('(a)b(c)'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_64_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_64_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14420,11 +13930,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_64_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_64_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14438,11 +13949,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_64_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_64_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14472,11 +13984,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_64_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_64_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14490,11 +14003,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_64_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_64_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14524,10 +14038,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_64_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_64_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14535,19 +14050,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_64_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_64_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_64_matcher::to_string() -> std::string{return R"('a+b+c'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_64_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_64_matcher::to_string() -> std::string{return R"('a+b+c'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_65_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_65_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14577,11 +14092,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_65_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_65_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14595,11 +14111,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_65_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_65_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14629,11 +14146,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_65_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_65_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14647,11 +14165,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_65_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_65_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14681,10 +14200,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_65_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_65_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14692,19 +14212,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_65_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_65_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_65_matcher::to_string() -> std::string{return R"('a{1,}b{1,}c'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_65_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_65_matcher::to_string() -> std::string{return R"('a{1,}b{1,}c'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_66_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_66_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14719,11 +14239,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_66_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_66_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14753,11 +14274,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_66_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_66_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14787,10 +14309,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_66_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_66_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14798,19 +14321,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_66_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_66_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_66_matcher::to_string() -> std::string{return R"('a.+?c'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_66_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_66_matcher::to_string() -> std::string{return R"('a.+?c'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_67_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_67_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14825,11 +14348,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_67_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_67_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14859,11 +14383,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_67_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_67_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14893,10 +14418,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_67_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_67_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14904,19 +14430,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_67_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_67_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_67_matcher::to_string() -> std::string{return R"('a.*?c'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_67_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_67_matcher::to_string() -> std::string{return R"('a.*?c'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_68_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_68_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14931,11 +14457,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_68_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_68_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14965,11 +14492,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_68_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_68_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14999,10 +14527,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_68_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_68_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15010,19 +14539,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_68_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_68_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_68_matcher::to_string() -> std::string{return R"('a.{0,5}?c'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_68_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_68_matcher::to_string() -> std::string{return R"('a.{0,5}?c'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15052,11 +14581,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15070,11 +14600,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15088,11 +14619,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15122,11 +14654,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15141,11 +14674,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15171,16 +14705,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_12_case_insensitive::regex_69_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_12_case_insensitive::regex_69_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15194,11 +14729,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15212,10 +14748,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15223,19 +14760,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::to_string() -> std::string{return R"('(a+|b)*'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_69_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_69_matcher::to_string() -> std::string{return R"('(a+|b)*'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15265,11 +14802,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15283,11 +14821,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15301,11 +14840,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15335,11 +14875,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15354,11 +14895,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15384,16 +14926,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_12_case_insensitive::regex_70_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_12_case_insensitive::regex_70_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15407,11 +14950,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15425,10 +14969,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15436,19 +14981,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::to_string() -> std::string{return R"('(a+|b){0,}'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_70_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_70_matcher::to_string() -> std::string{return R"('(a+|b){0,}'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15478,11 +15023,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15496,11 +15042,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15514,11 +15061,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15548,11 +15096,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15567,11 +15116,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15597,16 +15147,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_12_case_insensitive::regex_71_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_12_case_insensitive::regex_71_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15620,11 +15171,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15638,10 +15190,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15649,19 +15202,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::to_string() -> std::string{return R"('(a+|b)+'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_71_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_71_matcher::to_string() -> std::string{return R"('(a+|b)+'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15691,11 +15244,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15709,11 +15263,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15727,11 +15282,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15761,11 +15317,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15780,11 +15337,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15810,16 +15368,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_12_case_insensitive::regex_72_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_12_case_insensitive::regex_72_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15833,11 +15392,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15851,10 +15411,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15862,19 +15423,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::to_string() -> std::string{return R"('(a+|b){1,}'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_72_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_72_matcher::to_string() -> std::string{return R"('(a+|b){1,}'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15904,11 +15465,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15922,11 +15484,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15940,11 +15503,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15974,11 +15538,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15993,11 +15558,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16023,16 +15589,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_12_case_insensitive::regex_73_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_12_case_insensitive::regex_73_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16046,11 +15613,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16064,10 +15632,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -16075,19 +15644,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::to_string() -> std::string{return R"('(a+|b)?'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_73_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_73_matcher::to_string() -> std::string{return R"('(a+|b)?'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16117,11 +15686,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16135,11 +15705,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16153,11 +15724,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16187,11 +15759,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16206,11 +15779,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16236,16 +15810,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_12_case_insensitive::regex_74_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_12_case_insensitive::regex_74_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16259,11 +15834,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16277,10 +15853,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -16288,19 +15865,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::to_string() -> std::string{return R"('(a+|b){0,1}'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_74_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_74_matcher::to_string() -> std::string{return R"('(a+|b){0,1}'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16330,11 +15907,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16348,11 +15926,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16366,11 +15945,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16400,11 +15980,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16419,11 +16000,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16449,16 +16031,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_12_case_insensitive::regex_75_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_12_case_insensitive::regex_75_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16472,11 +16055,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16490,10 +16074,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -16501,19 +16086,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::to_string() -> std::string{return R"('(a+|b){0,1}?'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_75_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_75_matcher::to_string() -> std::string{return R"('(a+|b){0,1}?'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_76_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_76_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16528,11 +16113,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_76_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_76_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16546,11 +16132,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_76_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_76_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16564,10 +16151,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_76_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_76_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -16575,19 +16163,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_76_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_76_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_76_matcher::to_string() -> std::string{return R"('[^ab]*'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_76_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_76_matcher::to_string() -> std::string{return R"('[^ab]*'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_77_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_77_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16617,10 +16205,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_77_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_77_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -16628,19 +16217,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_77_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_77_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_77_matcher::to_string() -> std::string{return R"('abc'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_77_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_77_matcher::to_string() -> std::string{return R"('abc'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_78_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_78_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16670,11 +16259,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_78_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_78_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16688,11 +16278,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_78_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_78_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16706,10 +16297,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_78_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_78_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -16717,19 +16309,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_78_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_78_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_78_matcher::to_string() -> std::string{return R"('a*'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_78_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_78_matcher::to_string() -> std::string{return R"('a*'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_79_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_79_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16757,16 +16349,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_12_case_insensitive::regex_79_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_12_case_insensitive::regex_79_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_79_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_79_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16780,11 +16373,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_79_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_79_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16814,10 +16408,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_79_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_79_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -16825,19 +16420,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_79_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_79_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_79_matcher::to_string() -> std::string{return R"('([abc])*d'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_79_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_79_matcher::to_string() -> std::string{return R"('([abc])*d'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_80_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_80_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16865,16 +16460,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_12_case_insensitive::regex_80_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_12_case_insensitive::regex_80_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_80_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_80_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16888,11 +16484,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_80_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_80_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16922,10 +16519,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_80_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_80_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -16933,19 +16531,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_80_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_80_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_80_matcher::to_string() -> std::string{return R"('([abc])*bcd'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_80_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_80_matcher::to_string() -> std::string{return R"('([abc])*bcd'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -16975,11 +16573,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17009,11 +16608,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17043,11 +16643,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17077,11 +16678,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17111,11 +16713,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17129,11 +16732,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17147,10 +16751,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -17158,19 +16763,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::to_string() -> std::string{return R"('a|b|c|d|e'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_81_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_81_matcher::to_string() -> std::string{return R"('a|b|c|d|e'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17200,11 +16805,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17234,11 +16840,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17268,11 +16875,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17302,11 +16910,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17336,11 +16945,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17355,11 +16965,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17401,10 +17012,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -17412,19 +17024,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::to_string() -> std::string{return R"('(a|b|c|d|e)f'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_82_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_82_matcher::to_string() -> std::string{return R"('(a|b|c|d|e)f'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_83_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_83_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17454,11 +17066,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_83_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_83_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17488,11 +17101,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_83_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_83_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17522,10 +17136,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_83_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_83_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -17533,19 +17148,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_83_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_83_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_83_matcher::to_string() -> std::string{return R"('abcd*efg'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_83_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_83_matcher::to_string() -> std::string{return R"('abcd*efg'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_84_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_84_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17575,11 +17190,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_84_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_84_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17609,11 +17225,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_84_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_84_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17627,10 +17244,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_84_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_84_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -17638,19 +17256,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_84_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_84_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_84_matcher::to_string() -> std::string{return R"('ab*'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_84_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_84_matcher::to_string() -> std::string{return R"('ab*'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_85_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_85_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17680,11 +17298,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_85_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_85_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17714,11 +17333,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_85_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_85_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17732,10 +17352,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_85_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_85_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -17743,19 +17364,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_85_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_85_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_85_matcher::to_string() -> std::string{return R"('ab*'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_85_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_85_matcher::to_string() -> std::string{return R"('ab*'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_86_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_86_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17785,11 +17406,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_86_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_86_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17819,11 +17441,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_86_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_86_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17838,11 +17461,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_86_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_86_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17884,10 +17508,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_86_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_86_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -17895,19 +17520,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_86_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_86_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_86_matcher::to_string() -> std::string{return R"('(ab|cd)e'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_86_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_86_matcher::to_string() -> std::string{return R"('(ab|cd)e'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_87_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_87_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17938,10 +17563,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_87_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_87_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -17949,19 +17575,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_87_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_87_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_87_matcher::to_string() -> std::string{return R"('[abhgefdc]ij'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_87_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_87_matcher::to_string() -> std::string{return R"('[abhgefdc]ij'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_88_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_88_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -17991,11 +17617,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_88_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_88_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18025,11 +17652,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_88_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_88_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18045,11 +17673,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_88_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_88_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18091,10 +17720,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_88_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_88_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -18102,19 +17732,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_88_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_88_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_88_matcher::to_string() -> std::string{return R"('^(ab|cd)e'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_88_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_88_matcher::to_string() -> std::string{return R"('^(ab|cd)e'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_89_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_89_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18144,11 +17774,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_89_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_89_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18162,11 +17793,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_89_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_89_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18181,11 +17813,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_89_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_89_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18227,10 +17860,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_89_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_89_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -18238,19 +17872,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_89_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_89_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_89_matcher::to_string() -> std::string{return R"('(abc|)ef'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_89_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_89_matcher::to_string() -> std::string{return R"('(abc|)ef'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_90_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_90_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18280,11 +17914,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_90_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_90_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18314,11 +17949,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_90_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_90_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18333,11 +17969,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_90_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_90_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18367,11 +18004,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_90_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_90_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18397,11 +18035,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_90_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_90_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18431,10 +18070,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_90_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_90_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -18442,19 +18082,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_90_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_90_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_90_matcher::to_string() -> std::string{return R"('(a|b)c*d'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_90_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_90_matcher::to_string() -> std::string{return R"('(a|b)c*d'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_91_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_91_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18484,11 +18124,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_91_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_91_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18518,11 +18159,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_91_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_91_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18552,11 +18194,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_91_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_91_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18570,11 +18213,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_91_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_91_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18589,11 +18233,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_91_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_91_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18635,10 +18280,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_91_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_91_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -18646,19 +18292,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_91_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_91_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_91_matcher::to_string() -> std::string{return R"('(ab|ab*)bc'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_91_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_91_matcher::to_string() -> std::string{return R"('(ab|ab*)bc'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_92_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_92_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18673,11 +18319,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_92_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_92_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18708,11 +18355,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_92_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_92_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18742,11 +18390,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_92_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_92_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18772,11 +18421,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_92_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_92_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18790,10 +18440,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_92_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_92_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -18801,19 +18452,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_92_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_92_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_92_matcher::to_string() -> std::string{return R"('a([bc]*)c*'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_92_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_92_matcher::to_string() -> std::string{return R"('a([bc]*)c*'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_93_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_93_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18828,11 +18479,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_93_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_93_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18863,11 +18515,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_93_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_93_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18897,11 +18550,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_93_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_93_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18928,11 +18582,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_93_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_93_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -18974,10 +18629,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_93_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_93_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -18985,19 +18641,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_93_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_93_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_93_matcher::to_string() -> std::string{return R"('a([bc]*)(c*d)'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_93_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_93_matcher::to_string() -> std::string{return R"('a([bc]*)(c*d)'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_94_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_94_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19012,11 +18668,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_94_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_94_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19047,11 +18704,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_94_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_94_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19081,11 +18739,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_94_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_94_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19112,11 +18771,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_94_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_94_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19158,10 +18818,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_94_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_94_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -19169,19 +18830,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_94_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_94_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_94_matcher::to_string() -> std::string{return R"('a([bc]+)(c*d)'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_94_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_94_matcher::to_string() -> std::string{return R"('a([bc]+)(c*d)'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_95_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_95_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19196,11 +18857,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_95_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_95_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19231,11 +18893,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_95_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_95_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19265,11 +18928,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_95_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_95_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19296,11 +18960,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_95_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_95_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19342,10 +19007,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_95_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_95_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -19353,19 +19019,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_95_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_95_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_95_matcher::to_string() -> std::string{return R"('a([bc]*)(c+d)'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_95_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_95_matcher::to_string() -> std::string{return R"('a([bc]*)(c+d)'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_96_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_96_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19380,11 +19046,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_96_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_96_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19414,11 +19081,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_96_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_96_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19448,10 +19116,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_96_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_96_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -19459,19 +19128,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_96_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_96_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_96_matcher::to_string() -> std::string{return R"('a[bcd]*dcdcde'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_96_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_96_matcher::to_string() -> std::string{return R"('a[bcd]*dcdcde'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_97_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_97_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19486,11 +19155,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_97_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_97_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19520,11 +19190,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_97_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_97_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19554,10 +19225,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_97_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_97_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -19565,19 +19237,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_97_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_97_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_97_matcher::to_string() -> std::string{return R"('a[bcd]+dcdcde'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_97_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_97_matcher::to_string() -> std::string{return R"('a[bcd]+dcdcde'i)"; } - - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_98_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_98_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19607,11 +19279,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_98_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_98_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19641,11 +19314,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_98_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_98_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19660,11 +19334,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_98_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_98_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19694,11 +19369,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_98_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_98_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19724,11 +19400,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_98_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_98_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19758,10 +19435,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_98_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_98_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -19769,19 +19447,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_98_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_98_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_98_matcher::to_string() -> std::string{return R"('(ab|a)b*c'i)"; } - + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_98_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_98_matcher::to_string() -> std::string{return R"('(ab|a)b*c'i)"; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_99_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_99_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -19911,10 +19589,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_99_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_12_case_insensitive::regex_99_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -19922,15 +19601,16 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_12_case_insensitive::regex_99_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_12_case_insensitive::regex_99_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_12_case_insensitive::regex_99_matcher::to_string() -> std::string{return R"('((a)(b)c)(d)'i)"; } + template [[nodiscard]] constexpr auto test_tests_12_case_insensitive::regex_99_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_12_case_insensitive::regex_99_matcher::to_string() -> std::string{return R"('((a)(b)c)(d)'i)"; } -#line 409 "pure2-regex_12_case_insensitive.cpp2" +#line 410 "pure2-regex_12_case_insensitive.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_12_case_insensitive()); } diff --git a/regression-tests/test-results/pure2-regex_13_possessive_modifier.cpp b/regression-tests/test-results/pure2-regex_13_possessive_modifier.cpp index ff9242c4aa..5970247df0 100644 --- a/regression-tests/test-results/pure2-regex_13_possessive_modifier.cpp +++ b/regression-tests/test-results/pure2-regex_13_possessive_modifier.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_13_possessive_modifier.cpp2" -#line 165 "pure2-regex_13_possessive_modifier.cpp2" +#line 166 "pure2-regex_13_possessive_modifier.cpp2" class test_tests_13_possessive_modifier; @@ -18,47 +18,41 @@ class test_tests_13_possessive_modifier; #line 1 "pure2-regex_13_possessive_modifier.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_13_possessive_modifier.cpp2" +#line 113 "pure2-regex_13_possessive_modifier.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_13_possessive_modifier.cpp2" +#line 125 "pure2-regex_13_possessive_modifier.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_13_possessive_modifier.cpp2" +#line 166 "pure2-regex_13_possessive_modifier.cpp2" class test_tests_13_possessive_modifier { -#line 214 "pure2-regex_13_possessive_modifier.cpp2" +#line 215 "pure2-regex_13_possessive_modifier.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -66,35 +60,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -102,35 +90,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_02 {}; public: class regex_03_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_03_matcher() = default; public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -138,35 +120,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_03 {}; public: class regex_04_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_04_matcher() = default; public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -174,35 +150,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_04 {}; public: class regex_05_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_05_matcher() = default; public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -210,35 +180,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_05 {}; public: class regex_06_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_06_matcher() = default; public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -246,35 +210,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_06 {}; public: class regex_07_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_06 {}; public: template class regex_07_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_07_matcher() = default; public: regex_07_matcher(regex_07_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -282,35 +240,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_07 {}; public: class regex_08_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_07 {}; public: template class regex_08_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_08_matcher() = default; public: regex_08_matcher(regex_08_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -318,35 +270,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_08 {}; public: class regex_09_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_08 {}; public: template class regex_09_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_09_matcher() = default; public: regex_09_matcher(regex_09_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -354,35 +300,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_09 {}; public: class regex_10_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_09 {}; public: template class regex_10_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_10_matcher() = default; public: regex_10_matcher(regex_10_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -390,35 +330,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_10 {}; public: class regex_11_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_10 {}; public: template class regex_11_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_11_matcher() = default; public: regex_11_matcher(regex_11_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -426,35 +360,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_11 {}; public: class regex_12_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_11 {}; public: template class regex_12_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_12_matcher() = default; public: regex_12_matcher(regex_12_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -462,35 +390,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_12 {}; public: class regex_13_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_12 {}; public: template class regex_13_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_13_matcher() = default; public: regex_13_matcher(regex_13_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -498,35 +420,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_13 {}; public: class regex_14_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_13 {}; public: template class regex_14_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_14_matcher() = default; public: regex_14_matcher(regex_14_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -534,35 +450,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_14 {}; public: class regex_15_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_14 {}; public: template class regex_15_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_15_matcher() = default; public: regex_15_matcher(regex_15_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -570,35 +480,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_15 {}; public: class regex_16_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_15 {}; public: template class regex_16_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_16_matcher() = default; public: regex_16_matcher(regex_16_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -606,11 +510,10 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_16 {}; public: class regex_17_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_16 {}; public: template class regex_17_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -620,26 +523,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_17_matcher() = default; public: regex_17_matcher(regex_17_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -647,26 +545,25 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_17 {}; public: class regex_18_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_17 {}; public: template class regex_18_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -676,41 +573,36 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_18_matcher() = default; public: regex_18_matcher(regex_18_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -718,11 +610,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_18 {}; public: class regex_19_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_18 {}; public: template class regex_19_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -732,26 +623,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_19_matcher() = default; public: regex_19_matcher(regex_19_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -759,26 +645,25 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_19 {}; public: class regex_20_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_19 {}; public: template class regex_20_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -788,41 +673,36 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_20_matcher() = default; public: regex_20_matcher(regex_20_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -830,11 +710,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_20 {}; public: class regex_21_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_20 {}; public: template class regex_21_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -844,26 +723,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_21_matcher() = default; public: regex_21_matcher(regex_21_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -871,26 +745,25 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_21 {}; public: class regex_22_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_21 {}; public: template class regex_22_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -900,41 +773,36 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_22_matcher() = default; public: regex_22_matcher(regex_22_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -942,11 +810,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_22 {}; public: class regex_23_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_22 {}; public: template class regex_23_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -956,26 +823,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_23_matcher() = default; public: regex_23_matcher(regex_23_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -983,26 +845,25 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_23 {}; public: class regex_24_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_23 {}; public: template class regex_24_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1012,41 +873,36 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_24_matcher() = default; public: regex_24_matcher(regex_24_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1054,11 +910,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_24 {}; public: class regex_25_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_24 {}; public: template class regex_25_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1068,26 +923,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_25_matcher() = default; public: regex_25_matcher(regex_25_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1095,26 +945,25 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_25 {}; public: class regex_26_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_25 {}; public: template class regex_26_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1124,26 +973,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_26_matcher() = default; public: regex_26_matcher(regex_26_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1151,11 +995,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_26 {}; public: class regex_27_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_26 {}; public: template class regex_27_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1165,26 +1008,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_27_matcher() = default; public: regex_27_matcher(regex_27_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1192,26 +1030,25 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_27 {}; public: class regex_28_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_27 {}; public: template class regex_28_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1221,26 +1058,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_28_matcher() = default; public: regex_28_matcher(regex_28_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1248,11 +1080,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_28 {}; public: class regex_29_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_28 {}; public: template class regex_29_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1262,26 +1093,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_29_matcher() = default; public: regex_29_matcher(regex_29_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1289,26 +1115,25 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_29 {}; public: class regex_30_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_29 {}; public: template class regex_30_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1318,26 +1143,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_30_matcher() = default; public: regex_30_matcher(regex_30_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1345,11 +1165,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_30 {}; public: class regex_31_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_30 {}; public: template class regex_31_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1359,26 +1178,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_31_matcher() = default; public: regex_31_matcher(regex_31_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1386,26 +1200,25 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_31 {}; public: class regex_32_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_31 {}; public: template class regex_32_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1415,26 +1228,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_32_matcher() = default; public: regex_32_matcher(regex_32_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1442,11 +1250,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_32 {}; public: class regex_33_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_32 {}; public: template class regex_33_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1456,26 +1263,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_33_matcher() = default; public: regex_33_matcher(regex_33_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1483,26 +1285,25 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_33 {}; public: class regex_34_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_33 {}; public: template class regex_34_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1512,41 +1313,36 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_34_matcher() = default; public: regex_34_matcher(regex_34_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1554,11 +1350,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_34 {}; public: class regex_35_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_34 {}; public: template class regex_35_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1568,26 +1363,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_35_matcher() = default; public: regex_35_matcher(regex_35_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1595,26 +1385,25 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_35 {}; public: class regex_36_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_35 {}; public: template class regex_36_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1624,41 +1413,36 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_36_matcher() = default; public: regex_36_matcher(regex_36_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1666,11 +1450,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_36 {}; public: class regex_37_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_36 {}; public: template class regex_37_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1680,26 +1463,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_37_matcher() = default; public: regex_37_matcher(regex_37_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1707,26 +1485,25 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_37 {}; public: class regex_38_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_37 {}; public: template class regex_38_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1736,41 +1513,36 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_38_matcher() = default; public: regex_38_matcher(regex_38_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1778,11 +1550,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_38 {}; public: class regex_39_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_38 {}; public: template class regex_39_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1792,26 +1563,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_39_matcher() = default; public: regex_39_matcher(regex_39_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1819,26 +1585,25 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_39 {}; public: class regex_40_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_39 {}; public: template class regex_40_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1848,41 +1613,36 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_40_matcher() = default; public: regex_40_matcher(regex_40_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1890,11 +1650,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_40 {}; public: class regex_41_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_40 {}; public: template class regex_41_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1904,26 +1663,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_41_matcher() = default; public: regex_41_matcher(regex_41_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1931,26 +1685,25 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_41 {}; public: class regex_42_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_41 {}; public: template class regex_42_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1960,26 +1713,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_42_matcher() = default; public: regex_42_matcher(regex_42_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1987,11 +1735,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_42 {}; public: class regex_43_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_42 {}; public: template class regex_43_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -2001,26 +1748,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_43_matcher() = default; public: regex_43_matcher(regex_43_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2028,26 +1770,25 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_43 {}; public: class regex_44_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_43 {}; public: template class regex_44_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -2057,26 +1798,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_44_matcher() = default; public: regex_44_matcher(regex_44_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2084,11 +1820,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_44 {}; public: class regex_45_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_44 {}; public: template class regex_45_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -2098,26 +1833,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_45_matcher() = default; public: regex_45_matcher(regex_45_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2125,26 +1855,25 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_45 {}; public: class regex_46_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_45 {}; public: template class regex_46_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -2154,26 +1883,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_46_matcher() = default; public: regex_46_matcher(regex_46_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2181,11 +1905,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_46 {}; public: class regex_47_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_46 {}; public: template class regex_47_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -2195,26 +1918,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_47_matcher() = default; public: regex_47_matcher(regex_47_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2222,26 +1940,25 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_47 {}; public: class regex_48_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_47 {}; public: template class regex_48_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -2251,26 +1968,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_48_matcher() = default; public: regex_48_matcher(regex_48_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2278,13 +1990,13 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_48 {}; + public: cpp2::regex::regular_expression> regex_48 {}; public: test_tests_13_possessive_modifier() = default; public: test_tests_13_possessive_modifier(test_tests_13_possessive_modifier const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_13_possessive_modifier const&) -> void = delete; -#line 266 "pure2-regex_13_possessive_modifier.cpp2" +#line 267 "pure2-regex_13_possessive_modifier.cpp2" }; auto main() -> int; @@ -2388,6 +2100,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -2403,7 +2116,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_13_possessive_modifier.cpp2" +#line 113 "pure2-regex_13_possessive_modifier.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -2416,7 +2129,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_13_possessive_modifier.cpp2" +#line 125 "pure2-regex_13_possessive_modifier.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -2457,7 +2170,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 214 "pure2-regex_13_possessive_modifier.cpp2" +#line 215 "pure2-regex_13_possessive_modifier.cpp2" auto test_tests_13_possessive_modifier::run() const& -> void{ std::cout << "Running tests_13_possessive_modifier:" << std::endl; test(regex_01, "01", R"(a++a)", "aaaaa", "n", R"(-)", "-"); @@ -2514,8 +2227,7 @@ template auto test(M const& regex, cpp2::impl::in id, c - - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_01_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_01_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2543,11 +2255,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2561,11 +2274,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_01_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_01_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2593,10 +2307,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2604,19 +2319,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_01_matcher::to_string() -> std::string{return R"(a++a)"; } + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_01_matcher::to_string() -> std::string{return R"(a++a)"; } - - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_02_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_02_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2644,11 +2359,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2662,11 +2378,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_02_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_02_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2694,10 +2411,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2705,19 +2423,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_02_matcher::to_string() -> std::string{return R"(a*+a)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_02_matcher::to_string() -> std::string{return R"(a*+a)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_03_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_03_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2745,11 +2463,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_03_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2763,11 +2482,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_03_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_03_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2795,10 +2515,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_03_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2806,19 +2527,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_03_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_03_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_03_matcher::to_string() -> std::string{return R"(a{1,5}+a)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_03_matcher::to_string() -> std::string{return R"(a{1,5}+a)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_04_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_04_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2846,11 +2567,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_04_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2864,11 +2586,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_04_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_04_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2896,10 +2619,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_04_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2907,19 +2631,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_04_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_04_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_04_matcher::to_string() -> std::string{return R"(a?+a)"; } + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_04_matcher::to_string() -> std::string{return R"(a?+a)"; } - - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_05_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_05_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2947,11 +2671,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_05_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2965,11 +2690,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_05_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_05_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2997,10 +2723,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_05_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3008,19 +2735,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_05_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_05_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_05_matcher::to_string() -> std::string{return R"(a++b)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_05_matcher::to_string() -> std::string{return R"(a++b)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_06_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_06_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3048,11 +2775,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_06_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3066,11 +2794,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_06_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_06_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3098,10 +2827,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_06_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3109,19 +2839,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_06_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_06_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_06_matcher::to_string() -> std::string{return R"(a*+b)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_06_matcher::to_string() -> std::string{return R"(a*+b)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_07_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_07_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3149,11 +2879,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_07_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_07_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3167,11 +2898,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_07_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_07_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3199,10 +2931,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_07_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_07_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3210,19 +2943,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_07_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_07_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_07_matcher::to_string() -> std::string{return R"(a{1,5}+b)"; } + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_07_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_07_matcher::to_string() -> std::string{return R"(a{1,5}+b)"; } - - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_08_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_08_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3250,11 +2983,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_08_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_08_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3268,11 +3002,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_08_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_08_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3300,10 +3035,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_08_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_08_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3311,19 +3047,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_08_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_08_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_08_matcher::to_string() -> std::string{return R"(a?+b)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_08_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_08_matcher::to_string() -> std::string{return R"(a?+b)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_09_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_09_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3351,11 +3087,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_09_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_09_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3383,11 +3120,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_09_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_09_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3415,10 +3153,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_09_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_09_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3426,19 +3165,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_09_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_09_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_09_matcher::to_string() -> std::string{return R"(fooa++a)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_09_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_09_matcher::to_string() -> std::string{return R"(fooa++a)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_10_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_10_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3466,11 +3205,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_10_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_10_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3498,11 +3238,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_10_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_10_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3530,10 +3271,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_10_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_10_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3541,19 +3283,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_10_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_10_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_10_matcher::to_string() -> std::string{return R"(fooa*+a)"; } + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_10_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_10_matcher::to_string() -> std::string{return R"(fooa*+a)"; } - - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_11_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_11_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3581,11 +3323,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_11_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_11_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3613,11 +3356,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_11_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_11_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3645,10 +3389,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_11_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_11_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3656,19 +3401,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_11_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_11_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_11_matcher::to_string() -> std::string{return R"(fooa{1,5}+a)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_11_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_11_matcher::to_string() -> std::string{return R"(fooa{1,5}+a)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_12_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_12_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3696,11 +3441,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_12_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_12_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3728,11 +3474,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_12_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_12_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3760,10 +3507,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_12_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_12_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3771,19 +3519,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_12_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_12_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_12_matcher::to_string() -> std::string{return R"(fooa?+a)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_12_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_12_matcher::to_string() -> std::string{return R"(fooa?+a)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_13_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_13_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3811,11 +3559,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_13_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_13_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3843,11 +3592,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_13_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_13_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3875,10 +3625,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_13_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_13_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3886,19 +3637,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_13_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_13_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_13_matcher::to_string() -> std::string{return R"(fooa++b)"; } + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_13_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_13_matcher::to_string() -> std::string{return R"(fooa++b)"; } - - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_14_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_14_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3926,11 +3677,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_14_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_14_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3958,11 +3710,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_14_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_14_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3990,10 +3743,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_14_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_14_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4001,19 +3755,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_14_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_14_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_14_matcher::to_string() -> std::string{return R"(fooa*+b)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_14_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_14_matcher::to_string() -> std::string{return R"(fooa*+b)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_15_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_15_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4041,11 +3795,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_15_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_15_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4073,11 +3828,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_15_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_15_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4105,10 +3861,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_15_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_15_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4116,19 +3873,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_15_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_15_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_15_matcher::to_string() -> std::string{return R"(fooa{1,5}+b)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_15_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_15_matcher::to_string() -> std::string{return R"(fooa{1,5}+b)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_16_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_16_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4156,11 +3913,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_16_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_16_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4188,11 +3946,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_16_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_16_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4220,10 +3979,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_16_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_16_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4231,19 +3991,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_16_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_16_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_16_matcher::to_string() -> std::string{return R"(fooa?+b)"; } + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_16_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_16_matcher::to_string() -> std::string{return R"(fooa?+b)"; } - - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_17_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_17_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4284,16 +4044,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_17_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_17_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_17_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_17_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4307,11 +4068,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_17_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_17_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4352,10 +4114,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_17_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_17_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4363,19 +4126,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_17_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_17_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_17_matcher::to_string() -> std::string{return R"((aA)++(aA))"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_17_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_17_matcher::to_string() -> std::string{return R"((aA)++(aA))"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4403,11 +4166,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4435,11 +4199,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4454,11 +4219,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4484,16 +4250,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_18_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_18_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4507,11 +4274,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4539,11 +4307,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4571,11 +4340,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4590,11 +4360,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4620,10 +4391,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4631,19 +4403,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::to_string() -> std::string{return R"((aA|bB)++(aA|bB))"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_18_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_18_matcher::to_string() -> std::string{return R"((aA|bB)++(aA|bB))"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_19_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_19_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4684,16 +4456,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_19_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_19_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_19_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_19_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4707,11 +4480,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_19_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_19_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4752,10 +4526,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_19_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_19_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4763,19 +4538,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_19_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_19_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_19_matcher::to_string() -> std::string{return R"((aA)*+(aA))"; } + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_19_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_19_matcher::to_string() -> std::string{return R"((aA)*+(aA))"; } - - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4803,11 +4578,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4835,11 +4611,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4854,11 +4631,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4884,16 +4662,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_20_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_20_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4907,11 +4686,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4939,11 +4719,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4971,11 +4752,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4990,11 +4772,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5020,10 +4803,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5031,19 +4815,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::to_string() -> std::string{return R"((aA|bB)*+(aA|bB))"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_20_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_20_matcher::to_string() -> std::string{return R"((aA|bB)*+(aA|bB))"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_21_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_21_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5084,16 +4868,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_21_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_21_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_21_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_21_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5107,11 +4892,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_21_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_21_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5152,10 +4938,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_21_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_21_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5163,19 +4950,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_21_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_21_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_21_matcher::to_string() -> std::string{return R"((aA){1,5}+(aA))"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_21_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_21_matcher::to_string() -> std::string{return R"((aA){1,5}+(aA))"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5203,11 +4990,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5235,11 +5023,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5254,11 +5043,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5284,16 +5074,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_22_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_22_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5307,11 +5098,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5339,11 +5131,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5371,11 +5164,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5390,11 +5184,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5420,10 +5215,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5431,19 +5227,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::to_string() -> std::string{return R"((aA|bB){1,5}+(aA|bB))"; } + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_22_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_22_matcher::to_string() -> std::string{return R"((aA|bB){1,5}+(aA|bB))"; } - - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_23_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_23_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5484,16 +5280,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_23_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_23_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_23_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_23_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5507,11 +5304,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_23_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_23_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5552,10 +5350,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_23_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_23_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5563,19 +5362,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_23_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_23_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_23_matcher::to_string() -> std::string{return R"((aA)?+(aA))"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_23_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_23_matcher::to_string() -> std::string{return R"((aA)?+(aA))"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5603,11 +5402,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5635,11 +5435,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5654,11 +5455,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5684,16 +5486,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_24_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_24_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5707,11 +5510,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5739,11 +5543,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5771,11 +5576,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5790,11 +5596,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5820,10 +5627,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5831,19 +5639,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::to_string() -> std::string{return R"((aA|bB)?+(aA|bB))"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_24_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_24_matcher::to_string() -> std::string{return R"((aA|bB)?+(aA|bB))"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_25_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_25_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5884,16 +5692,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_25_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_25_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_25_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_25_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5907,11 +5716,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_25_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_25_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5939,10 +5749,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_25_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_25_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5950,19 +5761,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_25_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_25_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_25_matcher::to_string() -> std::string{return R"((aA)++b)"; } + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_25_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_25_matcher::to_string() -> std::string{return R"((aA)++b)"; } - - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_26_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_26_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5990,11 +5801,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_26_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_26_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6022,11 +5834,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_26_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_26_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6041,11 +5854,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_26_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_26_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6071,16 +5885,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_26_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_26_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_26_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_26_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6094,11 +5909,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_26_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_26_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6126,10 +5942,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_26_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_26_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6137,19 +5954,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_26_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_26_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_26_matcher::to_string() -> std::string{return R"((aA|bB)++b)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_26_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_26_matcher::to_string() -> std::string{return R"((aA|bB)++b)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_27_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_27_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6190,16 +6007,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_27_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_27_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_27_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_27_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6213,11 +6031,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_27_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_27_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6245,10 +6064,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_27_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_27_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6256,19 +6076,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_27_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_27_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_27_matcher::to_string() -> std::string{return R"((aA)*+b)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_27_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_27_matcher::to_string() -> std::string{return R"((aA)*+b)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_28_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_28_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6296,11 +6116,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_28_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_28_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6328,11 +6149,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_28_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_28_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6347,11 +6169,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_28_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_28_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6377,16 +6200,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_28_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_28_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_28_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_28_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6400,11 +6224,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_28_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_28_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6432,10 +6257,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_28_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_28_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6443,19 +6269,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_28_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_28_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_28_matcher::to_string() -> std::string{return R"((aA|bB)*+b)"; } + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_28_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_28_matcher::to_string() -> std::string{return R"((aA|bB)*+b)"; } - - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_29_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_29_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6496,16 +6322,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_29_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_29_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_29_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_29_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6519,11 +6346,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_29_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_29_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6551,10 +6379,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_29_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_29_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6562,19 +6391,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_29_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_29_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_29_matcher::to_string() -> std::string{return R"((aA){1,5}+b)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_29_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_29_matcher::to_string() -> std::string{return R"((aA){1,5}+b)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_30_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_30_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6602,11 +6431,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_30_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_30_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6634,11 +6464,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_30_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_30_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6653,11 +6484,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_30_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_30_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6683,16 +6515,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_30_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_30_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_30_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_30_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6706,11 +6539,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_30_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_30_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6738,10 +6572,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_30_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_30_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6749,19 +6584,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_30_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_30_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_30_matcher::to_string() -> std::string{return R"((aA|bB){1,5}+b)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_30_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_30_matcher::to_string() -> std::string{return R"((aA|bB){1,5}+b)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_31_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_31_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6802,16 +6637,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_31_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_31_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_31_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_31_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6825,11 +6661,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_31_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_31_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6857,10 +6694,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_31_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_31_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6868,19 +6706,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_31_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_31_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_31_matcher::to_string() -> std::string{return R"((aA)?+b)"; } + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_31_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_31_matcher::to_string() -> std::string{return R"((aA)?+b)"; } - - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_32_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_32_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6908,11 +6746,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_32_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_32_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6940,11 +6779,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_32_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_32_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6959,11 +6799,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_32_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_32_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6989,16 +6830,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_32_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_32_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_32_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_32_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7012,11 +6854,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_32_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_32_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7044,10 +6887,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_32_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_32_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7055,19 +6899,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_32_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_32_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_32_matcher::to_string() -> std::string{return R"((aA|bB)?+b)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_32_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_32_matcher::to_string() -> std::string{return R"((aA|bB)?+b)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_33_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_33_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7108,16 +6952,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_33_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_33_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_33_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_33_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7145,11 +6990,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_33_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_33_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7190,10 +7036,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_33_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_33_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7201,19 +7048,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_33_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_33_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_33_matcher::to_string() -> std::string{return R"(foo(aA)++(aA))"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_33_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_33_matcher::to_string() -> std::string{return R"(foo(aA)++(aA))"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7241,11 +7088,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7273,11 +7121,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7292,11 +7141,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7322,16 +7172,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_34_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_34_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7359,11 +7210,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7391,11 +7243,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7423,11 +7276,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7442,11 +7296,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7472,10 +7327,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7483,19 +7339,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::to_string() -> std::string{return R"(foo(aA|bB)++(aA|bB))"; } + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_34_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_34_matcher::to_string() -> std::string{return R"(foo(aA|bB)++(aA|bB))"; } - - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_35_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_35_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7536,16 +7392,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_35_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_35_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_35_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_35_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7573,11 +7430,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_35_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_35_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7618,10 +7476,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_35_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_35_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7629,19 +7488,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_35_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_35_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_35_matcher::to_string() -> std::string{return R"(foo(aA)*+(aA))"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_35_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_35_matcher::to_string() -> std::string{return R"(foo(aA)*+(aA))"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7669,11 +7528,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7701,11 +7561,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7720,11 +7581,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7750,16 +7612,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_36_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_36_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7787,11 +7650,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7819,11 +7683,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7851,11 +7716,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7870,11 +7736,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7900,10 +7767,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7911,19 +7779,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::to_string() -> std::string{return R"(foo(aA|bB)*+(aA|bB))"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_36_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_36_matcher::to_string() -> std::string{return R"(foo(aA|bB)*+(aA|bB))"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_37_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_37_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7964,16 +7832,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_37_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_37_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_37_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_37_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8001,11 +7870,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_37_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_37_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8046,10 +7916,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_37_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_37_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8057,19 +7928,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_37_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_37_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_37_matcher::to_string() -> std::string{return R"(foo(aA){1,5}+(aA))"; } + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_37_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_37_matcher::to_string() -> std::string{return R"(foo(aA){1,5}+(aA))"; } - - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8097,11 +7968,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8129,11 +8001,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8148,11 +8021,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8178,16 +8052,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_38_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_38_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8215,11 +8090,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8247,11 +8123,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8279,11 +8156,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8298,11 +8176,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8328,10 +8207,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8339,19 +8219,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::to_string() -> std::string{return R"(foo(aA|bB){1,5}+(aA|bB))"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_38_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_38_matcher::to_string() -> std::string{return R"(foo(aA|bB){1,5}+(aA|bB))"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_39_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_39_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8392,16 +8272,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_39_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_39_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_39_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_39_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8429,11 +8310,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_39_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_39_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8474,10 +8356,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_39_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_39_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8485,19 +8368,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_39_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_39_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_39_matcher::to_string() -> std::string{return R"(foo(aA)?+(aA))"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_39_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_39_matcher::to_string() -> std::string{return R"(foo(aA)?+(aA))"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8525,11 +8408,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8557,11 +8441,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8576,11 +8461,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8606,16 +8492,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_40_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_40_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8643,11 +8530,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8675,11 +8563,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8707,11 +8596,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8726,11 +8616,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8756,10 +8647,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8767,19 +8659,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::to_string() -> std::string{return R"(foo(aA|bB)?+(aA|bB))"; } + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_40_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_40_matcher::to_string() -> std::string{return R"(foo(aA|bB)?+(aA|bB))"; } - - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_41_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_41_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8820,16 +8712,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_41_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_41_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_41_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_41_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8857,11 +8750,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_41_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_41_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8889,10 +8783,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_41_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_41_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8900,19 +8795,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_41_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_41_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_41_matcher::to_string() -> std::string{return R"(foo(aA)++b)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_41_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_41_matcher::to_string() -> std::string{return R"(foo(aA)++b)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_42_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_42_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8940,11 +8835,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_42_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_42_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8972,11 +8868,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_42_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_42_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8991,11 +8888,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_42_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_42_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9021,16 +8919,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_42_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_42_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_42_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_42_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9058,11 +8957,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_42_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_42_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9090,10 +8990,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_42_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_42_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9101,19 +9002,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_42_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_42_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_42_matcher::to_string() -> std::string{return R"(foo(aA|bB)++b)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_42_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_42_matcher::to_string() -> std::string{return R"(foo(aA|bB)++b)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_43_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_43_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9154,16 +9055,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_43_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_43_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_43_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_43_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9191,11 +9093,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_43_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_43_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9223,10 +9126,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_43_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_43_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9234,19 +9138,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_43_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_43_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_43_matcher::to_string() -> std::string{return R"(foo(aA)*+b)"; } + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_43_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_43_matcher::to_string() -> std::string{return R"(foo(aA)*+b)"; } - - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_44_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_44_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9274,11 +9178,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_44_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_44_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9306,11 +9211,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_44_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_44_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9325,11 +9231,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_44_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_44_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9355,16 +9262,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_44_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_44_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_44_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_44_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9392,11 +9300,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_44_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_44_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9424,10 +9333,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_44_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_44_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9435,19 +9345,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_44_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_44_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_44_matcher::to_string() -> std::string{return R"(foo(aA|bB)*+b)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_44_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_44_matcher::to_string() -> std::string{return R"(foo(aA|bB)*+b)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_45_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_45_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9488,16 +9398,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_45_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_45_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_45_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_45_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9525,11 +9436,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_45_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_45_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9557,10 +9469,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_45_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_45_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9568,19 +9481,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_45_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_45_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_45_matcher::to_string() -> std::string{return R"(foo(aA){1,5}+b)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_45_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_45_matcher::to_string() -> std::string{return R"(foo(aA){1,5}+b)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_46_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_46_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9608,11 +9521,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_46_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_46_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9640,11 +9554,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_46_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_46_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9659,11 +9574,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_46_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_46_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9689,16 +9605,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_46_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_46_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_46_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_46_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9726,11 +9643,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_46_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_46_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9758,10 +9676,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_46_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_46_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9769,19 +9688,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_46_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_46_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_46_matcher::to_string() -> std::string{return R"(foo(aA|bB){1,5}+b)"; } + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_46_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_46_matcher::to_string() -> std::string{return R"(foo(aA|bB){1,5}+b)"; } - - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_47_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_47_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9822,16 +9741,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_47_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_47_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_47_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_47_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9859,11 +9779,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_47_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_47_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9891,10 +9812,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_47_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_47_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9902,19 +9824,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_47_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_47_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_47_matcher::to_string() -> std::string{return R"(foo(aA)?+b)"; } - + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_47_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_47_matcher::to_string() -> std::string{return R"(foo(aA)?+b)"; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_48_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_48_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9942,11 +9864,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_48_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_48_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9974,11 +9897,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_48_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_48_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9993,11 +9917,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_48_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_48_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10023,16 +9948,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_13_possessive_modifier::regex_48_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_13_possessive_modifier::regex_48_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_48_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_48_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10060,11 +9986,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_48_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_48_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10092,10 +10019,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_48_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_48_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10103,15 +10031,16 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_48_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_48_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_13_possessive_modifier::regex_48_matcher::to_string() -> std::string{return R"(foo(aA|bB)?+b)"; } + template [[nodiscard]] constexpr auto test_tests_13_possessive_modifier::regex_48_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_13_possessive_modifier::regex_48_matcher::to_string() -> std::string{return R"(foo(aA|bB)?+b)"; } -#line 267 "pure2-regex_13_possessive_modifier.cpp2" +#line 268 "pure2-regex_13_possessive_modifier.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_13_possessive_modifier()); } diff --git a/regression-tests/test-results/pure2-regex_14_multiline_modifier.cpp b/regression-tests/test-results/pure2-regex_14_multiline_modifier.cpp index eea7dae181..7fa9408467 100644 --- a/regression-tests/test-results/pure2-regex_14_multiline_modifier.cpp +++ b/regression-tests/test-results/pure2-regex_14_multiline_modifier.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_14_multiline_modifier.cpp2" -#line 165 "pure2-regex_14_multiline_modifier.cpp2" +#line 166 "pure2-regex_14_multiline_modifier.cpp2" class test_tests_14_multiline_modifier; @@ -18,37 +18,31 @@ class test_tests_14_multiline_modifier; #line 1 "pure2-regex_14_multiline_modifier.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_14_multiline_modifier.cpp2" +#line 113 "pure2-regex_14_multiline_modifier.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_14_multiline_modifier.cpp2" +#line 125 "pure2-regex_14_multiline_modifier.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_14_multiline_modifier.cpp2" +#line 166 "pure2-regex_14_multiline_modifier.cpp2" class test_tests_14_multiline_modifier { -#line 365 "pure2-regex_14_multiline_modifier.cpp2" +#line 366 "pure2-regex_14_multiline_modifier.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -56,25 +50,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -82,25 +70,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_02 {}; public: class regex_03_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_03_matcher() = default; public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -108,25 +90,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_03 {}; public: class regex_04_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_04_matcher() = default; public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -134,25 +110,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_04 {}; public: class regex_05_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_05_matcher() = default; public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -160,25 +130,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_05 {}; public: class regex_06_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_06_matcher() = default; public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -186,25 +150,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_06 {}; public: class regex_07_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_06 {}; public: template class regex_07_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_07_matcher() = default; public: regex_07_matcher(regex_07_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -212,25 +170,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_07 {}; public: class regex_08_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_07 {}; public: template class regex_08_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_08_matcher() = default; public: regex_08_matcher(regex_08_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -238,25 +190,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_08 {}; public: class regex_09_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_08 {}; public: template class regex_09_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_09_matcher() = default; public: regex_09_matcher(regex_09_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -264,25 +210,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_09 {}; public: class regex_10_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_09 {}; public: template class regex_10_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_10_matcher() = default; public: regex_10_matcher(regex_10_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -290,25 +230,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_10 {}; public: class regex_100_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_10 {}; public: template class regex_100_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_100_matcher() = default; public: regex_100_matcher(regex_100_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -316,25 +250,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_100 {}; public: class regex_101_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_100 {}; public: template class regex_101_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_101_matcher() = default; public: regex_101_matcher(regex_101_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -342,25 +270,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_101 {}; public: class regex_102_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_101 {}; public: template class regex_102_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_102_matcher() = default; public: regex_102_matcher(regex_102_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -368,25 +290,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_102 {}; public: class regex_103_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_102 {}; public: template class regex_103_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_103_matcher() = default; public: regex_103_matcher(regex_103_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -394,25 +310,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_103 {}; public: class regex_104_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_103 {}; public: template class regex_104_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_104_matcher() = default; public: regex_104_matcher(regex_104_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -420,25 +330,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_104 {}; public: class regex_105_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_104 {}; public: template class regex_105_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_105_matcher() = default; public: regex_105_matcher(regex_105_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -446,25 +350,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_105 {}; public: class regex_106_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_105 {}; public: template class regex_106_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_106_matcher() = default; public: regex_106_matcher(regex_106_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -472,25 +370,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_106 {}; public: class regex_107_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_106 {}; public: template class regex_107_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_107_matcher() = default; public: regex_107_matcher(regex_107_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -498,25 +390,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_107 {}; public: class regex_108_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_107 {}; public: template class regex_108_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_108_matcher() = default; public: regex_108_matcher(regex_108_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -524,25 +410,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_108 {}; public: class regex_109_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_108 {}; public: template class regex_109_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_109_matcher() = default; public: regex_109_matcher(regex_109_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -550,25 +430,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_109 {}; public: class regex_11_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_109 {}; public: template class regex_11_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_11_matcher() = default; public: regex_11_matcher(regex_11_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -576,25 +450,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_11 {}; public: class regex_110_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_11 {}; public: template class regex_110_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_110_matcher() = default; public: regex_110_matcher(regex_110_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -602,25 +470,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_110 {}; public: class regex_111_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_110 {}; public: template class regex_111_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_111_matcher() = default; public: regex_111_matcher(regex_111_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -628,25 +490,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_111 {}; public: class regex_112_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_111 {}; public: template class regex_112_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_112_matcher() = default; public: regex_112_matcher(regex_112_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -654,25 +510,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_112 {}; public: class regex_113_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_112 {}; public: template class regex_113_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_113_matcher() = default; public: regex_113_matcher(regex_113_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -680,25 +530,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_113 {}; public: class regex_114_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_113 {}; public: template class regex_114_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_114_matcher() = default; public: regex_114_matcher(regex_114_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -706,25 +550,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_114 {}; public: class regex_115_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_114 {}; public: template class regex_115_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_115_matcher() = default; public: regex_115_matcher(regex_115_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -732,25 +570,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_115 {}; public: class regex_116_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_115 {}; public: template class regex_116_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_116_matcher() = default; public: regex_116_matcher(regex_116_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -758,25 +590,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_116 {}; public: class regex_117_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_116 {}; public: template class regex_117_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_117_matcher() = default; public: regex_117_matcher(regex_117_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -784,25 +610,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_117 {}; public: class regex_118_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_117 {}; public: template class regex_118_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_118_matcher() = default; public: regex_118_matcher(regex_118_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -810,25 +630,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_118 {}; public: class regex_119_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_118 {}; public: template class regex_119_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_119_matcher() = default; public: regex_119_matcher(regex_119_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -836,25 +650,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_119 {}; public: class regex_12_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_119 {}; public: template class regex_12_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_12_matcher() = default; public: regex_12_matcher(regex_12_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -862,25 +670,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_12 {}; public: class regex_120_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_12 {}; public: template class regex_120_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_120_matcher() = default; public: regex_120_matcher(regex_120_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -888,25 +690,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_120 {}; public: class regex_121_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_120 {}; public: template class regex_121_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_121_matcher() = default; public: regex_121_matcher(regex_121_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -914,25 +710,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_121 {}; public: class regex_122_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_121 {}; public: template class regex_122_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_122_matcher() = default; public: regex_122_matcher(regex_122_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -940,25 +730,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_122 {}; public: class regex_123_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_122 {}; public: template class regex_123_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_123_matcher() = default; public: regex_123_matcher(regex_123_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -966,25 +750,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_123 {}; public: class regex_124_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_123 {}; public: template class regex_124_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_124_matcher() = default; public: regex_124_matcher(regex_124_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -992,25 +770,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_124 {}; public: class regex_125_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_124 {}; public: template class regex_125_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_125_matcher() = default; public: regex_125_matcher(regex_125_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1018,25 +790,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_125 {}; public: class regex_126_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_125 {}; public: template class regex_126_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_126_matcher() = default; public: regex_126_matcher(regex_126_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1044,25 +810,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_126 {}; public: class regex_127_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_126 {}; public: template class regex_127_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_127_matcher() = default; public: regex_127_matcher(regex_127_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1070,25 +830,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_127 {}; public: class regex_128_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_127 {}; public: template class regex_128_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_128_matcher() = default; public: regex_128_matcher(regex_128_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1096,25 +850,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_128 {}; public: class regex_129_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_128 {}; public: template class regex_129_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_129_matcher() = default; public: regex_129_matcher(regex_129_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1122,25 +870,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_129 {}; public: class regex_13_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_129 {}; public: template class regex_13_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_13_matcher() = default; public: regex_13_matcher(regex_13_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1148,25 +890,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_13 {}; public: class regex_130_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_13 {}; public: template class regex_130_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_130_matcher() = default; public: regex_130_matcher(regex_130_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1174,25 +910,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_130 {}; public: class regex_131_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_130 {}; public: template class regex_131_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_131_matcher() = default; public: regex_131_matcher(regex_131_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1200,25 +930,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_131 {}; public: class regex_132_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_131 {}; public: template class regex_132_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_132_matcher() = default; public: regex_132_matcher(regex_132_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1226,25 +950,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_132 {}; public: class regex_133_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_132 {}; public: template class regex_133_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_133_matcher() = default; public: regex_133_matcher(regex_133_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1252,25 +970,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_133 {}; public: class regex_134_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_133 {}; public: template class regex_134_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_134_matcher() = default; public: regex_134_matcher(regex_134_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1278,25 +990,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_134 {}; public: class regex_135_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_134 {}; public: template class regex_135_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_135_matcher() = default; public: regex_135_matcher(regex_135_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1304,25 +1010,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_135 {}; public: class regex_136_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_135 {}; public: template class regex_136_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_136_matcher() = default; public: regex_136_matcher(regex_136_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1330,25 +1030,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_136 {}; public: class regex_137_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_136 {}; public: template class regex_137_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_137_matcher() = default; public: regex_137_matcher(regex_137_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1356,25 +1050,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_137 {}; public: class regex_138_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_137 {}; public: template class regex_138_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_138_matcher() = default; public: regex_138_matcher(regex_138_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1382,25 +1070,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_138 {}; public: class regex_139_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_138 {}; public: template class regex_139_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_139_matcher() = default; public: regex_139_matcher(regex_139_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1408,25 +1090,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_139 {}; public: class regex_14_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_139 {}; public: template class regex_14_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_14_matcher() = default; public: regex_14_matcher(regex_14_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1434,25 +1110,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_14 {}; public: class regex_140_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_14 {}; public: template class regex_140_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_140_matcher() = default; public: regex_140_matcher(regex_140_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1460,25 +1130,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_140 {}; public: class regex_141_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_140 {}; public: template class regex_141_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_141_matcher() = default; public: regex_141_matcher(regex_141_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1486,25 +1150,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_141 {}; public: class regex_142_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_141 {}; public: template class regex_142_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_142_matcher() = default; public: regex_142_matcher(regex_142_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1512,25 +1170,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_142 {}; public: class regex_143_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_142 {}; public: template class regex_143_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_143_matcher() = default; public: regex_143_matcher(regex_143_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1538,25 +1190,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_143 {}; public: class regex_144_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_143 {}; public: template class regex_144_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_144_matcher() = default; public: regex_144_matcher(regex_144_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1564,25 +1210,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_144 {}; public: class regex_145_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_144 {}; public: template class regex_145_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_145_matcher() = default; public: regex_145_matcher(regex_145_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1590,25 +1230,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_145 {}; public: class regex_146_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_145 {}; public: template class regex_146_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_146_matcher() = default; public: regex_146_matcher(regex_146_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1616,25 +1250,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_146 {}; public: class regex_147_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_146 {}; public: template class regex_147_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_147_matcher() = default; public: regex_147_matcher(regex_147_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1642,25 +1270,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_147 {}; public: class regex_148_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_147 {}; public: template class regex_148_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_148_matcher() = default; public: regex_148_matcher(regex_148_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1668,25 +1290,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_148 {}; public: class regex_149_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_148 {}; public: template class regex_149_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_149_matcher() = default; public: regex_149_matcher(regex_149_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1694,25 +1310,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_149 {}; public: class regex_15_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_149 {}; public: template class regex_15_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_15_matcher() = default; public: regex_15_matcher(regex_15_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1720,25 +1330,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_15 {}; public: class regex_150_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_15 {}; public: template class regex_150_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_150_matcher() = default; public: regex_150_matcher(regex_150_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1746,25 +1350,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_150 {}; public: class regex_151_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_150 {}; public: template class regex_151_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_151_matcher() = default; public: regex_151_matcher(regex_151_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1772,25 +1370,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_151 {}; public: class regex_152_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_151 {}; public: template class regex_152_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_152_matcher() = default; public: regex_152_matcher(regex_152_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1798,25 +1390,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_152 {}; public: class regex_153_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_152 {}; public: template class regex_153_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_153_matcher() = default; public: regex_153_matcher(regex_153_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1824,25 +1410,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_153 {}; public: class regex_154_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_153 {}; public: template class regex_154_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_154_matcher() = default; public: regex_154_matcher(regex_154_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1850,25 +1430,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_154 {}; public: class regex_155_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_154 {}; public: template class regex_155_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_155_matcher() = default; public: regex_155_matcher(regex_155_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1876,25 +1450,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_155 {}; public: class regex_156_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_155 {}; public: template class regex_156_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_156_matcher() = default; public: regex_156_matcher(regex_156_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1902,25 +1470,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_156 {}; public: class regex_157_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_156 {}; public: template class regex_157_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_157_matcher() = default; public: regex_157_matcher(regex_157_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1928,25 +1490,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_157 {}; public: class regex_158_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_157 {}; public: template class regex_158_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_158_matcher() = default; public: regex_158_matcher(regex_158_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1954,25 +1510,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_158 {}; public: class regex_159_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_158 {}; public: template class regex_159_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_159_matcher() = default; public: regex_159_matcher(regex_159_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1980,25 +1530,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_159 {}; public: class regex_16_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_159 {}; public: template class regex_16_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_16_matcher() = default; public: regex_16_matcher(regex_16_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2006,25 +1550,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_16 {}; public: class regex_160_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_16 {}; public: template class regex_160_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_160_matcher() = default; public: regex_160_matcher(regex_160_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2032,25 +1570,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_160 {}; public: class regex_161_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_160 {}; public: template class regex_161_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_161_matcher() = default; public: regex_161_matcher(regex_161_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2058,25 +1590,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_161 {}; public: class regex_162_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_161 {}; public: template class regex_162_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_162_matcher() = default; public: regex_162_matcher(regex_162_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2084,25 +1610,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_162 {}; public: class regex_163_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_162 {}; public: template class regex_163_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_163_matcher() = default; public: regex_163_matcher(regex_163_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2110,25 +1630,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_163 {}; public: class regex_164_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_163 {}; public: template class regex_164_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_164_matcher() = default; public: regex_164_matcher(regex_164_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2136,25 +1650,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_164 {}; public: class regex_165_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_164 {}; public: template class regex_165_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_165_matcher() = default; public: regex_165_matcher(regex_165_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2162,25 +1670,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_165 {}; public: class regex_166_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_165 {}; public: template class regex_166_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_166_matcher() = default; public: regex_166_matcher(regex_166_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2188,25 +1690,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_166 {}; public: class regex_167_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_166 {}; public: template class regex_167_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_167_matcher() = default; public: regex_167_matcher(regex_167_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2214,25 +1710,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_167 {}; public: class regex_168_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_167 {}; public: template class regex_168_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_168_matcher() = default; public: regex_168_matcher(regex_168_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2240,25 +1730,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_168 {}; public: class regex_169_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_168 {}; public: template class regex_169_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_169_matcher() = default; public: regex_169_matcher(regex_169_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2266,25 +1750,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_169 {}; public: class regex_17_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_169 {}; public: template class regex_17_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_17_matcher() = default; public: regex_17_matcher(regex_17_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2292,25 +1770,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_17 {}; public: class regex_170_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_17 {}; public: template class regex_170_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_170_matcher() = default; public: regex_170_matcher(regex_170_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2318,25 +1790,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_170 {}; public: class regex_171_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_170 {}; public: template class regex_171_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_171_matcher() = default; public: regex_171_matcher(regex_171_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2344,25 +1810,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_171 {}; public: class regex_172_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_171 {}; public: template class regex_172_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_172_matcher() = default; public: regex_172_matcher(regex_172_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2370,25 +1830,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_172 {}; public: class regex_173_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_172 {}; public: template class regex_173_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_173_matcher() = default; public: regex_173_matcher(regex_173_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2396,25 +1850,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_173 {}; public: class regex_174_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_173 {}; public: template class regex_174_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_174_matcher() = default; public: regex_174_matcher(regex_174_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2422,25 +1870,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_174 {}; public: class regex_175_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_174 {}; public: template class regex_175_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_175_matcher() = default; public: regex_175_matcher(regex_175_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2448,25 +1890,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_175 {}; public: class regex_176_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_175 {}; public: template class regex_176_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_176_matcher() = default; public: regex_176_matcher(regex_176_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2474,25 +1910,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_176 {}; public: class regex_177_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_176 {}; public: template class regex_177_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_177_matcher() = default; public: regex_177_matcher(regex_177_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2500,25 +1930,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_177 {}; public: class regex_178_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_177 {}; public: template class regex_178_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; - public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_178_matcher() = default; public: regex_178_matcher(regex_178_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2526,25 +1950,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_178 {}; public: class regex_179_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_178 {}; public: template class regex_179_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_179_matcher() = default; public: regex_179_matcher(regex_179_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2552,25 +1970,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_179 {}; public: class regex_18_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_179 {}; public: template class regex_18_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_18_matcher() = default; public: regex_18_matcher(regex_18_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2578,25 +1990,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_18 {}; public: class regex_180_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_18 {}; public: template class regex_180_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_180_matcher() = default; public: regex_180_matcher(regex_180_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2604,25 +2010,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_180 {}; public: class regex_181_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_180 {}; public: template class regex_181_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_181_matcher() = default; public: regex_181_matcher(regex_181_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2630,25 +2030,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_181 {}; public: class regex_182_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_181 {}; public: template class regex_182_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_182_matcher() = default; public: regex_182_matcher(regex_182_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2656,25 +2050,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_182 {}; public: class regex_183_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_182 {}; public: template class regex_183_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_183_matcher() = default; public: regex_183_matcher(regex_183_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2682,25 +2070,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_183 {}; public: class regex_184_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_183 {}; public: template class regex_184_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_184_matcher() = default; public: regex_184_matcher(regex_184_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2708,25 +2090,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_184 {}; public: class regex_185_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_184 {}; public: template class regex_185_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_185_matcher() = default; public: regex_185_matcher(regex_185_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2734,25 +2110,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_185 {}; public: class regex_186_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_185 {}; public: template class regex_186_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_186_matcher() = default; public: regex_186_matcher(regex_186_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2760,25 +2130,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_186 {}; public: class regex_187_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_186 {}; public: template class regex_187_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_187_matcher() = default; public: regex_187_matcher(regex_187_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2786,25 +2150,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_187 {}; public: class regex_188_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_187 {}; public: template class regex_188_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_188_matcher() = default; public: regex_188_matcher(regex_188_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2812,25 +2170,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_188 {}; public: class regex_189_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_188 {}; public: template class regex_189_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_189_matcher() = default; public: regex_189_matcher(regex_189_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2838,25 +2190,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_189 {}; public: class regex_19_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_189 {}; public: template class regex_19_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_19_matcher() = default; public: regex_19_matcher(regex_19_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2864,25 +2210,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_19 {}; public: class regex_190_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_19 {}; public: template class regex_190_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_190_matcher() = default; public: regex_190_matcher(regex_190_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2890,25 +2230,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_190 {}; public: class regex_191_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_190 {}; public: template class regex_191_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_191_matcher() = default; public: regex_191_matcher(regex_191_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2916,25 +2250,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_191 {}; public: class regex_192_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_191 {}; public: template class regex_192_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_192_matcher() = default; public: regex_192_matcher(regex_192_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2942,25 +2270,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_192 {}; public: class regex_193_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_192 {}; public: template class regex_193_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_193_matcher() = default; public: regex_193_matcher(regex_193_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2968,25 +2290,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_193 {}; public: class regex_194_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_193 {}; public: template class regex_194_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_194_matcher() = default; public: regex_194_matcher(regex_194_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2994,25 +2310,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_194 {}; public: class regex_195_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_194 {}; public: template class regex_195_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_195_matcher() = default; public: regex_195_matcher(regex_195_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3020,25 +2330,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_195 {}; public: class regex_196_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_195 {}; public: template class regex_196_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_196_matcher() = default; public: regex_196_matcher(regex_196_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3046,25 +2350,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_196 {}; public: class regex_197_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_196 {}; public: template class regex_197_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_197_matcher() = default; public: regex_197_matcher(regex_197_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3072,25 +2370,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_197 {}; public: class regex_198_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_197 {}; public: template class regex_198_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_198_matcher() = default; public: regex_198_matcher(regex_198_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3098,25 +2390,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_198 {}; public: class regex_199_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_198 {}; public: template class regex_199_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_199_matcher() = default; public: regex_199_matcher(regex_199_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3124,25 +2410,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_199 {}; public: class regex_20_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_199 {}; public: template class regex_20_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_20_matcher() = default; public: regex_20_matcher(regex_20_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3150,25 +2430,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_20 {}; public: class regex_21_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_20 {}; public: template class regex_21_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_21_matcher() = default; public: regex_21_matcher(regex_21_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3176,25 +2450,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_21 {}; public: class regex_22_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_21 {}; public: template class regex_22_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_22_matcher() = default; public: regex_22_matcher(regex_22_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3202,25 +2470,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_22 {}; public: class regex_23_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_22 {}; public: template class regex_23_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_23_matcher() = default; public: regex_23_matcher(regex_23_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3228,25 +2490,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_23 {}; public: class regex_24_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_23 {}; public: template class regex_24_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_24_matcher() = default; public: regex_24_matcher(regex_24_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3254,25 +2510,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_24 {}; public: class regex_25_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_24 {}; public: template class regex_25_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_25_matcher() = default; public: regex_25_matcher(regex_25_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3280,25 +2530,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_25 {}; public: class regex_26_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_25 {}; public: template class regex_26_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_26_matcher() = default; public: regex_26_matcher(regex_26_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3306,25 +2550,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_26 {}; public: class regex_27_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_26 {}; public: template class regex_27_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_27_matcher() = default; public: regex_27_matcher(regex_27_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3332,25 +2570,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_27 {}; public: class regex_28_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_27 {}; public: template class regex_28_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_28_matcher() = default; public: regex_28_matcher(regex_28_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3358,25 +2590,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_28 {}; public: class regex_29_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_28 {}; public: template class regex_29_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_29_matcher() = default; public: regex_29_matcher(regex_29_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3384,25 +2610,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_29 {}; public: class regex_30_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_29 {}; public: template class regex_30_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_30_matcher() = default; public: regex_30_matcher(regex_30_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3410,25 +2630,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_30 {}; public: class regex_31_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_30 {}; public: template class regex_31_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_31_matcher() = default; public: regex_31_matcher(regex_31_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3436,25 +2650,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_31 {}; public: class regex_32_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_31 {}; public: template class regex_32_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_32_matcher() = default; public: regex_32_matcher(regex_32_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3462,25 +2670,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_32 {}; public: class regex_33_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_32 {}; public: template class regex_33_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_33_matcher() = default; public: regex_33_matcher(regex_33_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3488,25 +2690,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_33 {}; public: class regex_34_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_33 {}; public: template class regex_34_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_34_matcher() = default; public: regex_34_matcher(regex_34_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3514,25 +2710,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_34 {}; public: class regex_35_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_34 {}; public: template class regex_35_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_35_matcher() = default; public: regex_35_matcher(regex_35_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3540,25 +2730,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_35 {}; public: class regex_36_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_35 {}; public: template class regex_36_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_36_matcher() = default; public: regex_36_matcher(regex_36_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3566,25 +2750,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_36 {}; public: class regex_37_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_36 {}; public: template class regex_37_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_37_matcher() = default; public: regex_37_matcher(regex_37_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3592,25 +2770,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_37 {}; public: class regex_38_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_37 {}; public: template class regex_38_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_38_matcher() = default; public: regex_38_matcher(regex_38_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3618,25 +2790,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_38 {}; public: class regex_39_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_38 {}; public: template class regex_39_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_39_matcher() = default; public: regex_39_matcher(regex_39_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3644,25 +2810,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_39 {}; public: class regex_40_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_39 {}; public: template class regex_40_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_40_matcher() = default; public: regex_40_matcher(regex_40_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3670,25 +2830,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_40 {}; public: class regex_41_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_40 {}; public: template class regex_41_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_41_matcher() = default; public: regex_41_matcher(regex_41_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3696,25 +2850,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_41 {}; public: class regex_42_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_41 {}; public: template class regex_42_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_42_matcher() = default; public: regex_42_matcher(regex_42_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3722,25 +2870,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_42 {}; public: class regex_43_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_42 {}; public: template class regex_43_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_43_matcher() = default; public: regex_43_matcher(regex_43_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3748,25 +2890,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_43 {}; public: class regex_44_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_43 {}; public: template class regex_44_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_44_matcher() = default; public: regex_44_matcher(regex_44_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3774,25 +2910,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_44 {}; public: class regex_45_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_44 {}; public: template class regex_45_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_45_matcher() = default; public: regex_45_matcher(regex_45_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3800,25 +2930,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_45 {}; public: class regex_46_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_45 {}; public: template class regex_46_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_46_matcher() = default; public: regex_46_matcher(regex_46_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3826,25 +2950,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_46 {}; public: class regex_47_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_46 {}; public: template class regex_47_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_47_matcher() = default; public: regex_47_matcher(regex_47_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3852,25 +2970,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_47 {}; public: class regex_48_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_47 {}; public: template class regex_48_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_48_matcher() = default; public: regex_48_matcher(regex_48_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3878,25 +2990,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_48 {}; public: class regex_49_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_48 {}; public: template class regex_49_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_49_matcher() = default; public: regex_49_matcher(regex_49_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3904,25 +3010,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_49 {}; public: class regex_50_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_49 {}; public: template class regex_50_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_50_matcher() = default; public: regex_50_matcher(regex_50_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3930,25 +3030,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_50 {}; public: class regex_51_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_50 {}; public: template class regex_51_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_51_matcher() = default; public: regex_51_matcher(regex_51_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3956,25 +3050,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_51 {}; public: class regex_52_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_51 {}; public: template class regex_52_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_52_matcher() = default; public: regex_52_matcher(regex_52_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -3982,25 +3070,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_52 {}; public: class regex_53_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_52 {}; public: template class regex_53_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_53_matcher() = default; public: regex_53_matcher(regex_53_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4008,25 +3090,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_53 {}; public: class regex_54_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_53 {}; public: template class regex_54_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_54_matcher() = default; public: regex_54_matcher(regex_54_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4034,25 +3110,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_54 {}; public: class regex_55_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_54 {}; public: template class regex_55_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_55_matcher() = default; public: regex_55_matcher(regex_55_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4060,25 +3130,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_55 {}; public: class regex_56_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_55 {}; public: template class regex_56_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_56_matcher() = default; public: regex_56_matcher(regex_56_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4086,25 +3150,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_56 {}; public: class regex_57_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_56 {}; public: template class regex_57_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_57_matcher() = default; public: regex_57_matcher(regex_57_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4112,25 +3170,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_57 {}; public: class regex_58_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_57 {}; public: template class regex_58_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_58_matcher() = default; public: regex_58_matcher(regex_58_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4138,25 +3190,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_58 {}; public: class regex_59_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_58 {}; public: template class regex_59_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_59_matcher() = default; public: regex_59_matcher(regex_59_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4164,25 +3210,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_59 {}; public: class regex_60_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_59 {}; public: template class regex_60_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_60_matcher() = default; public: regex_60_matcher(regex_60_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4190,25 +3230,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_60 {}; public: class regex_61_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_60 {}; public: template class regex_61_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_61_matcher() = default; public: regex_61_matcher(regex_61_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4216,25 +3250,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_61 {}; public: class regex_62_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_61 {}; public: template class regex_62_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_62_matcher() = default; public: regex_62_matcher(regex_62_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4242,25 +3270,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_62 {}; public: class regex_63_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_62 {}; public: template class regex_63_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_63_matcher() = default; public: regex_63_matcher(regex_63_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4268,25 +3290,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_63 {}; public: class regex_64_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_63 {}; public: template class regex_64_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_64_matcher() = default; public: regex_64_matcher(regex_64_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4294,25 +3310,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_64 {}; public: class regex_65_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_64 {}; public: template class regex_65_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_65_matcher() = default; public: regex_65_matcher(regex_65_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4320,25 +3330,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_65 {}; public: class regex_66_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_65 {}; public: template class regex_66_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_66_matcher() = default; public: regex_66_matcher(regex_66_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4346,25 +3350,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_66 {}; public: class regex_67_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_66 {}; public: template class regex_67_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_67_matcher() = default; public: regex_67_matcher(regex_67_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4372,25 +3370,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_67 {}; public: class regex_68_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_67 {}; public: template class regex_68_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_68_matcher() = default; public: regex_68_matcher(regex_68_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4398,25 +3390,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_68 {}; public: class regex_69_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_68 {}; public: template class regex_69_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_69_matcher() = default; public: regex_69_matcher(regex_69_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4424,25 +3410,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_69 {}; public: class regex_70_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_69 {}; public: template class regex_70_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_70_matcher() = default; public: regex_70_matcher(regex_70_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4450,25 +3430,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_70 {}; public: class regex_71_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_70 {}; public: template class regex_71_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_71_matcher() = default; public: regex_71_matcher(regex_71_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4476,25 +3450,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_71 {}; public: class regex_72_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_71 {}; public: template class regex_72_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_72_matcher() = default; public: regex_72_matcher(regex_72_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4502,25 +3470,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_72 {}; public: class regex_73_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_72 {}; public: template class regex_73_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_73_matcher() = default; public: regex_73_matcher(regex_73_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4528,25 +3490,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_73 {}; public: class regex_74_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_73 {}; public: template class regex_74_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_74_matcher() = default; public: regex_74_matcher(regex_74_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4554,25 +3510,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_74 {}; public: class regex_75_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_74 {}; public: template class regex_75_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_75_matcher() = default; public: regex_75_matcher(regex_75_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4580,25 +3530,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_75 {}; public: class regex_76_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_75 {}; public: template class regex_76_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_76_matcher() = default; public: regex_76_matcher(regex_76_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4606,25 +3550,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_76 {}; public: class regex_77_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_76 {}; public: template class regex_77_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_77_matcher() = default; public: regex_77_matcher(regex_77_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4632,25 +3570,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_77 {}; public: class regex_78_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_77 {}; public: template class regex_78_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_78_matcher() = default; public: regex_78_matcher(regex_78_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4658,25 +3590,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_78 {}; public: class regex_79_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_78 {}; public: template class regex_79_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_79_matcher() = default; public: regex_79_matcher(regex_79_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4684,25 +3610,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_79 {}; public: class regex_80_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_79 {}; public: template class regex_80_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_80_matcher() = default; public: regex_80_matcher(regex_80_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4710,25 +3630,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_80 {}; public: class regex_81_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_80 {}; public: template class regex_81_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_81_matcher() = default; public: regex_81_matcher(regex_81_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4736,25 +3650,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_81 {}; public: class regex_82_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_81 {}; public: template class regex_82_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_82_matcher() = default; public: regex_82_matcher(regex_82_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4762,25 +3670,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_82 {}; public: class regex_83_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_82 {}; public: template class regex_83_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_83_matcher() = default; public: regex_83_matcher(regex_83_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4788,25 +3690,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_83 {}; public: class regex_84_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_83 {}; public: template class regex_84_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_84_matcher() = default; public: regex_84_matcher(regex_84_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4814,25 +3710,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_84 {}; public: class regex_85_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_84 {}; public: template class regex_85_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_85_matcher() = default; public: regex_85_matcher(regex_85_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4840,25 +3730,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_85 {}; public: class regex_86_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_85 {}; public: template class regex_86_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_86_matcher() = default; public: regex_86_matcher(regex_86_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4866,25 +3750,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_86 {}; public: class regex_87_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_86 {}; public: template class regex_87_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_87_matcher() = default; public: regex_87_matcher(regex_87_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4892,25 +3770,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_87 {}; public: class regex_88_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_87 {}; public: template class regex_88_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_88_matcher() = default; public: regex_88_matcher(regex_88_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4918,25 +3790,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_88 {}; public: class regex_89_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_88 {}; public: template class regex_89_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_89_matcher() = default; public: regex_89_matcher(regex_89_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4944,25 +3810,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_89 {}; public: class regex_90_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_89 {}; public: template class regex_90_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_90_matcher() = default; public: regex_90_matcher(regex_90_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4970,25 +3830,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_90 {}; public: class regex_91_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_90 {}; public: template class regex_91_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_91_matcher() = default; public: regex_91_matcher(regex_91_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -4996,25 +3850,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_91 {}; public: class regex_92_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_91 {}; public: template class regex_92_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_92_matcher() = default; public: regex_92_matcher(regex_92_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -5022,25 +3870,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_92 {}; public: class regex_93_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_92 {}; public: template class regex_93_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_93_matcher() = default; public: regex_93_matcher(regex_93_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -5048,25 +3890,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_93 {}; public: class regex_94_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_93 {}; public: template class regex_94_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_94_matcher() = default; public: regex_94_matcher(regex_94_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -5074,25 +3910,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_94 {}; public: class regex_95_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_94 {}; public: template class regex_95_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_95_matcher() = default; public: regex_95_matcher(regex_95_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -5100,25 +3930,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_95 {}; public: class regex_96_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_95 {}; public: template class regex_96_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_96_matcher() = default; public: regex_96_matcher(regex_96_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -5126,25 +3950,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_96 {}; public: class regex_97_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_96 {}; public: template class regex_97_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_97_matcher() = default; public: regex_97_matcher(regex_97_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -5152,25 +3970,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_97 {}; public: class regex_98_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_97 {}; public: template class regex_98_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_98_matcher() = default; public: regex_98_matcher(regex_98_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -5178,25 +3990,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_98 {}; public: class regex_99_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_98 {}; public: template class regex_99_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_99_matcher() = default; public: regex_99_matcher(regex_99_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -5204,13 +4010,13 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_99 {}; + public: cpp2::regex::regular_expression> regex_99 {}; public: test_tests_14_multiline_modifier() = default; public: test_tests_14_multiline_modifier(test_tests_14_multiline_modifier const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_14_multiline_modifier const&) -> void = delete; -#line 568 "pure2-regex_14_multiline_modifier.cpp2" +#line 569 "pure2-regex_14_multiline_modifier.cpp2" }; auto main() -> int; @@ -5314,6 +4120,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -5329,7 +4136,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_14_multiline_modifier.cpp2" +#line 113 "pure2-regex_14_multiline_modifier.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -5342,7 +4149,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_14_multiline_modifier.cpp2" +#line 125 "pure2-regex_14_multiline_modifier.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -5383,7 +4190,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 365 "pure2-regex_14_multiline_modifier.cpp2" +#line 366 "pure2-regex_14_multiline_modifier.cpp2" auto test_tests_14_multiline_modifier::run() const& -> void{ std::cout << "Running tests_14_multiline_modifier:" << std::endl; test(regex_01, "01", R"(\Z)", "a\nb\n", "y", R"($-[0])", "3"); @@ -5591,8 +4398,7 @@ template auto test(M const& regex, cpp2::impl::in id, c - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5607,10 +4413,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5618,19 +4425,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_01_matcher::to_string() -> std::string{return R"(\Z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_01_matcher::to_string() -> std::string{return R"(\Z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5645,10 +4452,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5656,19 +4464,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_02_matcher::to_string() -> std::string{return R"(\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_02_matcher::to_string() -> std::string{return R"(\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_03_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5683,10 +4491,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_03_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5694,19 +4503,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_03_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_03_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_03_matcher::to_string() -> std::string{return R"($)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_03_matcher::to_string() -> std::string{return R"($)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_04_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5721,10 +4530,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_04_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5732,19 +4542,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_04_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_04_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_04_matcher::to_string() -> std::string{return R"(\Z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_04_matcher::to_string() -> std::string{return R"(\Z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_05_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5759,10 +4569,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_05_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5770,19 +4581,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_05_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_05_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_05_matcher::to_string() -> std::string{return R"(\z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_05_matcher::to_string() -> std::string{return R"(\z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_06_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5797,10 +4608,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_06_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5808,19 +4620,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_06_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_06_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_06_matcher::to_string() -> std::string{return R"($)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_06_matcher::to_string() -> std::string{return R"($)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_07_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_07_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5835,10 +4647,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_07_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_07_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5846,19 +4659,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_07_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_07_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_07_matcher::to_string() -> std::string{return R"(\Z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_07_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_07_matcher::to_string() -> std::string{return R"(\Z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_08_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_08_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5873,10 +4686,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_08_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_08_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5884,19 +4698,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_08_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_08_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_08_matcher::to_string() -> std::string{return R"(\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_08_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_08_matcher::to_string() -> std::string{return R"(\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_09_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_09_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5911,10 +4725,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_09_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_09_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5922,19 +4737,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_09_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_09_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_09_matcher::to_string() -> std::string{return R"($)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_09_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_09_matcher::to_string() -> std::string{return R"($)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_10_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_10_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5949,10 +4764,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_10_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_10_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5960,19 +4776,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_10_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_10_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_10_matcher::to_string() -> std::string{return R"('\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_10_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_10_matcher::to_string() -> std::string{return R"('\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_100_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_100_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6001,10 +4817,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_100_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_100_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6012,19 +4829,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_100_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_100_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_100_matcher::to_string() -> std::string{return R"('ab\Z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_100_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_100_matcher::to_string() -> std::string{return R"('ab\Z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_101_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_101_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6053,10 +4870,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_101_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_101_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6064,19 +4882,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_101_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_101_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_101_matcher::to_string() -> std::string{return R"('ab\z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_101_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_101_matcher::to_string() -> std::string{return R"('ab\z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_102_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_102_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6105,10 +4923,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_102_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_102_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6116,19 +4935,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_102_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_102_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_102_matcher::to_string() -> std::string{return R"('ab$'m)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_102_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_102_matcher::to_string() -> std::string{return R"('ab$'m)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_103_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_103_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6157,10 +4976,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_103_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_103_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6168,19 +4988,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_103_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_103_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_103_matcher::to_string() -> std::string{return R"('ab\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_103_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_103_matcher::to_string() -> std::string{return R"('ab\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_104_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_104_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6209,10 +5029,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_104_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_104_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6220,19 +5041,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_104_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_104_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_104_matcher::to_string() -> std::string{return R"('ab\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_104_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_104_matcher::to_string() -> std::string{return R"('ab\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_105_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_105_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6261,10 +5082,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_105_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_105_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6272,19 +5094,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_105_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_105_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_105_matcher::to_string() -> std::string{return R"('ab$'m)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_105_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_105_matcher::to_string() -> std::string{return R"('ab$'m)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_106_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_106_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6313,10 +5135,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_106_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_106_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6324,19 +5147,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_106_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_106_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_106_matcher::to_string() -> std::string{return R"('ab\Z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_106_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_106_matcher::to_string() -> std::string{return R"('ab\Z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_107_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_107_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6365,10 +5188,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_107_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_107_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6376,19 +5200,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_107_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_107_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_107_matcher::to_string() -> std::string{return R"('ab\z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_107_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_107_matcher::to_string() -> std::string{return R"('ab\z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_108_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_108_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6417,10 +5241,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_108_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_108_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6428,19 +5253,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_108_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_108_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_108_matcher::to_string() -> std::string{return R"('ab$'m)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_108_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_108_matcher::to_string() -> std::string{return R"('ab$'m)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_109_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_109_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6469,10 +5294,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_109_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_109_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6480,19 +5306,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_109_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_109_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_109_matcher::to_string() -> std::string{return R"(ab\Z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_109_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_109_matcher::to_string() -> std::string{return R"(ab\Z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_11_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_11_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6507,10 +5333,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_11_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_11_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6518,19 +5345,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_11_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_11_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_11_matcher::to_string() -> std::string{return R"('\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_11_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_11_matcher::to_string() -> std::string{return R"('\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_110_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_110_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6559,10 +5386,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_110_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_110_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6570,19 +5398,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_110_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_110_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_110_matcher::to_string() -> std::string{return R"(ab\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_110_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_110_matcher::to_string() -> std::string{return R"(ab\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_111_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_111_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6611,10 +5439,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_111_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_111_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6622,19 +5451,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_111_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_111_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_111_matcher::to_string() -> std::string{return R"(ab$)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_111_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_111_matcher::to_string() -> std::string{return R"(ab$)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_112_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_112_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6663,10 +5492,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_112_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_112_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6674,19 +5504,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_112_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_112_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_112_matcher::to_string() -> std::string{return R"(ab\Z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_112_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_112_matcher::to_string() -> std::string{return R"(ab\Z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_113_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_113_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6715,10 +5545,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_113_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_113_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6726,19 +5557,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_113_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_113_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_113_matcher::to_string() -> std::string{return R"(ab\z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_113_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_113_matcher::to_string() -> std::string{return R"(ab\z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_114_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_114_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6767,10 +5598,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_114_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_114_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6778,19 +5610,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_114_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_114_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_114_matcher::to_string() -> std::string{return R"(ab$)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_114_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_114_matcher::to_string() -> std::string{return R"(ab$)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_115_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_115_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6819,10 +5651,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_115_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_115_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6830,19 +5663,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_115_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_115_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_115_matcher::to_string() -> std::string{return R"(ab\Z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_115_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_115_matcher::to_string() -> std::string{return R"(ab\Z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_116_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_116_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6871,10 +5704,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_116_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_116_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6882,19 +5716,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_116_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_116_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_116_matcher::to_string() -> std::string{return R"(ab\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_116_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_116_matcher::to_string() -> std::string{return R"(ab\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_117_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_117_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6923,10 +5757,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_117_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_117_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6934,19 +5769,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_117_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_117_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_117_matcher::to_string() -> std::string{return R"(ab$)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_117_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_117_matcher::to_string() -> std::string{return R"(ab$)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_118_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_118_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6975,10 +5810,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_118_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_118_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6986,19 +5822,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_118_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_118_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_118_matcher::to_string() -> std::string{return R"('ab\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_118_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_118_matcher::to_string() -> std::string{return R"('ab\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_119_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_119_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7027,10 +5863,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_119_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_119_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7038,19 +5875,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_119_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_119_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_119_matcher::to_string() -> std::string{return R"('ab\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_119_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_119_matcher::to_string() -> std::string{return R"('ab\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_12_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_12_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7065,10 +5902,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_12_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_12_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7076,19 +5914,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_12_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_12_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_12_matcher::to_string() -> std::string{return R"('$'m)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_12_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_12_matcher::to_string() -> std::string{return R"('$'m)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_120_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_120_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7117,10 +5955,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_120_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_120_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7128,19 +5967,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_120_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_120_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_120_matcher::to_string() -> std::string{return R"('ab$'m)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_120_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_120_matcher::to_string() -> std::string{return R"('ab$'m)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_121_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_121_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7169,10 +6008,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_121_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_121_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7180,19 +6020,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_121_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_121_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_121_matcher::to_string() -> std::string{return R"('ab\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_121_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_121_matcher::to_string() -> std::string{return R"('ab\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_122_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_122_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7221,10 +6061,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_122_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_122_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7232,19 +6073,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_122_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_122_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_122_matcher::to_string() -> std::string{return R"('ab\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_122_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_122_matcher::to_string() -> std::string{return R"('ab\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_123_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_123_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7273,10 +6114,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_123_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_123_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7284,19 +6126,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_123_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_123_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_123_matcher::to_string() -> std::string{return R"('ab$'m)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_123_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_123_matcher::to_string() -> std::string{return R"('ab$'m)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_124_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_124_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7325,10 +6167,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_124_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_124_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7336,19 +6179,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_124_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_124_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_124_matcher::to_string() -> std::string{return R"('ab\Z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_124_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_124_matcher::to_string() -> std::string{return R"('ab\Z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_125_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_125_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7377,10 +6220,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_125_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_125_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7388,19 +6232,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_125_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_125_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_125_matcher::to_string() -> std::string{return R"('ab\z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_125_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_125_matcher::to_string() -> std::string{return R"('ab\z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_126_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_126_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7429,10 +6273,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_126_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_126_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7440,19 +6285,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_126_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_126_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_126_matcher::to_string() -> std::string{return R"('ab$'m)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_126_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_126_matcher::to_string() -> std::string{return R"('ab$'m)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_127_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_127_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7481,10 +6326,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_127_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_127_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7492,19 +6338,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_127_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_127_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_127_matcher::to_string() -> std::string{return R"(ab\Z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_127_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_127_matcher::to_string() -> std::string{return R"(ab\Z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_128_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_128_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7533,10 +6379,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_128_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_128_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7544,19 +6391,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_128_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_128_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_128_matcher::to_string() -> std::string{return R"(ab\z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_128_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_128_matcher::to_string() -> std::string{return R"(ab\z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_129_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_129_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7585,10 +6432,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_129_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_129_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7596,19 +6444,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_129_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_129_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_129_matcher::to_string() -> std::string{return R"(ab$)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_129_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_129_matcher::to_string() -> std::string{return R"(ab$)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_13_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_13_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7623,10 +6471,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_13_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_13_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7634,19 +6483,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_13_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_13_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_13_matcher::to_string() -> std::string{return R"('\Z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_13_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_13_matcher::to_string() -> std::string{return R"('\Z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_130_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_130_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7675,10 +6524,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_130_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_130_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7686,19 +6536,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_130_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_130_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_130_matcher::to_string() -> std::string{return R"(ab\Z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_130_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_130_matcher::to_string() -> std::string{return R"(ab\Z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_131_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_131_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7727,10 +6577,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_131_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_131_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7738,19 +6589,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_131_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_131_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_131_matcher::to_string() -> std::string{return R"(ab\z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_131_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_131_matcher::to_string() -> std::string{return R"(ab\z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_132_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_132_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7779,10 +6630,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_132_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_132_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7790,19 +6642,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_132_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_132_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_132_matcher::to_string() -> std::string{return R"(ab$)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_132_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_132_matcher::to_string() -> std::string{return R"(ab$)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_133_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_133_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7831,10 +6683,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_133_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_133_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7842,19 +6695,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_133_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_133_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_133_matcher::to_string() -> std::string{return R"(ab\Z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_133_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_133_matcher::to_string() -> std::string{return R"(ab\Z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_134_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_134_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7883,10 +6736,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_134_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_134_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7894,19 +6748,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_134_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_134_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_134_matcher::to_string() -> std::string{return R"(ab\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_134_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_134_matcher::to_string() -> std::string{return R"(ab\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_135_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_135_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7935,10 +6789,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_135_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_135_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7946,19 +6801,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_135_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_135_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_135_matcher::to_string() -> std::string{return R"(ab$)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_135_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_135_matcher::to_string() -> std::string{return R"(ab$)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_136_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_136_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7987,10 +6842,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_136_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_136_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7998,19 +6854,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_136_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_136_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_136_matcher::to_string() -> std::string{return R"('ab\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_136_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_136_matcher::to_string() -> std::string{return R"('ab\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_137_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_137_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8039,10 +6895,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_137_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_137_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8050,19 +6907,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_137_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_137_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_137_matcher::to_string() -> std::string{return R"('ab\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_137_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_137_matcher::to_string() -> std::string{return R"('ab\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_138_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_138_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8091,10 +6948,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_138_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_138_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8102,19 +6960,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_138_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_138_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_138_matcher::to_string() -> std::string{return R"('ab$'m)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_138_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_138_matcher::to_string() -> std::string{return R"('ab$'m)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_139_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_139_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8143,10 +7001,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_139_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_139_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8154,19 +7013,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_139_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_139_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_139_matcher::to_string() -> std::string{return R"('ab\Z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_139_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_139_matcher::to_string() -> std::string{return R"('ab\Z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_14_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_14_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8181,10 +7040,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_14_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_14_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8192,19 +7052,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_14_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_14_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_14_matcher::to_string() -> std::string{return R"('\z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_14_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_14_matcher::to_string() -> std::string{return R"('\z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_140_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_140_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8233,10 +7093,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_140_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_140_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8244,19 +7105,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_140_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_140_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_140_matcher::to_string() -> std::string{return R"('ab\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_140_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_140_matcher::to_string() -> std::string{return R"('ab\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_141_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_141_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8285,10 +7146,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_141_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_141_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8296,19 +7158,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_141_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_141_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_141_matcher::to_string() -> std::string{return R"('ab$'m)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_141_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_141_matcher::to_string() -> std::string{return R"('ab$'m)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_142_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_142_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8337,10 +7199,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_142_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_142_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8348,19 +7211,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_142_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_142_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_142_matcher::to_string() -> std::string{return R"('ab\Z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_142_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_142_matcher::to_string() -> std::string{return R"('ab\Z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_143_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_143_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8389,10 +7252,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_143_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_143_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8400,19 +7264,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_143_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_143_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_143_matcher::to_string() -> std::string{return R"('ab\z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_143_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_143_matcher::to_string() -> std::string{return R"('ab\z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_144_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_144_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8441,10 +7305,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_144_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_144_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8452,19 +7317,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_144_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_144_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_144_matcher::to_string() -> std::string{return R"('ab$'m)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_144_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_144_matcher::to_string() -> std::string{return R"('ab$'m)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_145_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_145_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8493,10 +7358,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_145_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_145_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8504,19 +7370,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_145_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_145_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_145_matcher::to_string() -> std::string{return R"(abb\Z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_145_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_145_matcher::to_string() -> std::string{return R"(abb\Z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_146_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_146_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8545,10 +7411,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_146_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_146_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8556,19 +7423,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_146_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_146_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_146_matcher::to_string() -> std::string{return R"(abb\z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_146_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_146_matcher::to_string() -> std::string{return R"(abb\z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_147_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_147_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8597,10 +7464,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_147_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_147_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8608,19 +7476,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_147_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_147_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_147_matcher::to_string() -> std::string{return R"(abb$)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_147_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_147_matcher::to_string() -> std::string{return R"(abb$)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_148_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_148_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8649,10 +7517,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_148_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_148_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8660,19 +7529,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_148_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_148_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_148_matcher::to_string() -> std::string{return R"(abb\Z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_148_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_148_matcher::to_string() -> std::string{return R"(abb\Z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_149_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_149_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8701,10 +7570,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_149_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_149_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8712,19 +7582,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_149_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_149_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_149_matcher::to_string() -> std::string{return R"(abb\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_149_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_149_matcher::to_string() -> std::string{return R"(abb\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_15_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_15_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8739,10 +7609,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_15_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_15_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8750,19 +7621,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_15_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_15_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_15_matcher::to_string() -> std::string{return R"('$'m)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_15_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_15_matcher::to_string() -> std::string{return R"('$'m)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_150_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_150_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8791,10 +7662,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_150_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_150_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8802,19 +7674,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_150_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_150_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_150_matcher::to_string() -> std::string{return R"(abb$)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_150_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_150_matcher::to_string() -> std::string{return R"(abb$)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_151_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_151_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8843,10 +7715,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_151_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_151_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8854,19 +7727,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_151_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_151_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_151_matcher::to_string() -> std::string{return R"(abb\Z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_151_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_151_matcher::to_string() -> std::string{return R"(abb\Z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_152_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_152_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8895,10 +7768,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_152_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_152_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8906,19 +7780,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_152_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_152_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_152_matcher::to_string() -> std::string{return R"(abb\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_152_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_152_matcher::to_string() -> std::string{return R"(abb\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_153_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_153_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8947,10 +7821,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_153_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_153_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8958,19 +7833,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_153_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_153_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_153_matcher::to_string() -> std::string{return R"(abb$)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_153_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_153_matcher::to_string() -> std::string{return R"(abb$)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_154_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_154_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8999,10 +7874,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_154_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_154_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9010,19 +7886,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_154_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_154_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_154_matcher::to_string() -> std::string{return R"('abb\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_154_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_154_matcher::to_string() -> std::string{return R"('abb\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_155_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_155_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9051,10 +7927,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_155_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_155_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9062,19 +7939,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_155_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_155_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_155_matcher::to_string() -> std::string{return R"('abb\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_155_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_155_matcher::to_string() -> std::string{return R"('abb\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_156_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_156_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9103,10 +7980,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_156_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_156_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9114,19 +7992,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_156_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_156_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_156_matcher::to_string() -> std::string{return R"('abb$'m)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_156_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_156_matcher::to_string() -> std::string{return R"('abb$'m)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_157_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_157_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9155,10 +8033,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_157_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_157_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9166,19 +8045,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_157_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_157_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_157_matcher::to_string() -> std::string{return R"('abb\Z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_157_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_157_matcher::to_string() -> std::string{return R"('abb\Z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_158_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_158_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9207,10 +8086,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_158_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_158_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9218,19 +8098,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_158_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_158_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_158_matcher::to_string() -> std::string{return R"('abb\z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_158_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_158_matcher::to_string() -> std::string{return R"('abb\z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_159_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_159_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9259,10 +8139,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_159_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_159_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9270,19 +8151,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_159_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_159_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_159_matcher::to_string() -> std::string{return R"('abb$'m)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_159_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_159_matcher::to_string() -> std::string{return R"('abb$'m)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_16_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_16_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9297,10 +8178,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_16_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_16_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9308,19 +8190,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_16_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_16_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_16_matcher::to_string() -> std::string{return R"('\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_16_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_16_matcher::to_string() -> std::string{return R"('\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_160_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_160_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9349,10 +8231,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_160_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_160_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9360,19 +8243,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_160_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_160_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_160_matcher::to_string() -> std::string{return R"('abb\Z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_160_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_160_matcher::to_string() -> std::string{return R"('abb\Z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_161_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_161_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9401,10 +8284,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_161_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_161_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9412,19 +8296,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_161_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_161_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_161_matcher::to_string() -> std::string{return R"('abb\z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_161_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_161_matcher::to_string() -> std::string{return R"('abb\z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_162_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_162_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9453,10 +8337,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_162_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_162_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9464,19 +8349,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_162_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_162_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_162_matcher::to_string() -> std::string{return R"('abb$'m)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_162_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_162_matcher::to_string() -> std::string{return R"('abb$'m)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_163_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_163_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9505,10 +8390,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_163_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_163_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9516,19 +8402,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_163_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_163_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_163_matcher::to_string() -> std::string{return R"(abb\Z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_163_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_163_matcher::to_string() -> std::string{return R"(abb\Z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_164_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_164_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9557,10 +8443,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_164_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_164_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9568,19 +8455,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_164_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_164_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_164_matcher::to_string() -> std::string{return R"(abb\z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_164_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_164_matcher::to_string() -> std::string{return R"(abb\z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_165_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_165_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9609,10 +8496,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_165_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_165_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9620,19 +8508,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_165_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_165_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_165_matcher::to_string() -> std::string{return R"(abb$)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_165_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_165_matcher::to_string() -> std::string{return R"(abb$)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_166_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_166_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9661,10 +8549,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_166_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_166_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9672,19 +8561,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_166_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_166_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_166_matcher::to_string() -> std::string{return R"(abb\Z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_166_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_166_matcher::to_string() -> std::string{return R"(abb\Z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_167_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_167_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9713,10 +8602,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_167_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_167_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9724,19 +8614,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_167_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_167_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_167_matcher::to_string() -> std::string{return R"(abb\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_167_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_167_matcher::to_string() -> std::string{return R"(abb\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_168_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_168_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9765,10 +8655,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_168_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_168_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9776,19 +8667,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_168_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_168_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_168_matcher::to_string() -> std::string{return R"(abb$)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_168_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_168_matcher::to_string() -> std::string{return R"(abb$)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_169_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_169_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9817,10 +8708,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_169_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_169_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9828,19 +8720,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_169_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_169_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_169_matcher::to_string() -> std::string{return R"(abb\Z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_169_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_169_matcher::to_string() -> std::string{return R"(abb\Z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_17_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_17_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9855,10 +8747,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_17_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_17_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9866,19 +8759,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_17_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_17_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_17_matcher::to_string() -> std::string{return R"('\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_17_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_17_matcher::to_string() -> std::string{return R"('\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_170_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_170_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9907,10 +8800,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_170_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_170_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9918,19 +8812,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_170_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_170_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_170_matcher::to_string() -> std::string{return R"(abb\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_170_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_170_matcher::to_string() -> std::string{return R"(abb\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_171_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_171_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9959,10 +8853,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_171_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_171_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9970,19 +8865,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_171_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_171_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_171_matcher::to_string() -> std::string{return R"(abb$)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_171_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_171_matcher::to_string() -> std::string{return R"(abb$)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_172_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_172_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10011,10 +8906,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_172_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_172_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10022,19 +8918,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_172_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_172_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_172_matcher::to_string() -> std::string{return R"('abb\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_172_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_172_matcher::to_string() -> std::string{return R"('abb\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_173_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_173_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10063,10 +8959,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_173_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_173_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10074,19 +8971,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_173_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_173_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_173_matcher::to_string() -> std::string{return R"('abb\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_173_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_173_matcher::to_string() -> std::string{return R"('abb\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_174_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_174_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10115,10 +9012,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_174_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_174_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10126,19 +9024,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_174_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_174_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_174_matcher::to_string() -> std::string{return R"('abb$'m)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_174_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_174_matcher::to_string() -> std::string{return R"('abb$'m)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_175_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_175_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10167,10 +9065,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_175_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_175_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10178,19 +9077,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_175_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_175_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_175_matcher::to_string() -> std::string{return R"('abb\Z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_175_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_175_matcher::to_string() -> std::string{return R"('abb\Z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_176_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_176_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10219,10 +9118,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_176_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_176_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10230,19 +9130,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_176_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_176_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_176_matcher::to_string() -> std::string{return R"('abb\z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_176_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_176_matcher::to_string() -> std::string{return R"('abb\z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_177_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_177_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10271,10 +9171,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_177_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_177_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10282,19 +9183,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_177_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_177_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_177_matcher::to_string() -> std::string{return R"('abb$'m)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_177_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_177_matcher::to_string() -> std::string{return R"('abb$'m)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_178_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_178_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10323,10 +9224,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_178_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_178_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10334,19 +9236,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_178_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_178_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_178_matcher::to_string() -> std::string{return R"('abb\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_178_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_178_matcher::to_string() -> std::string{return R"('abb\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_179_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_179_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10375,10 +9277,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_179_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_179_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10386,19 +9289,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_179_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_179_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_179_matcher::to_string() -> std::string{return R"('abb\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_179_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_179_matcher::to_string() -> std::string{return R"('abb\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_18_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_18_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10413,10 +9316,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_18_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_18_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10424,19 +9328,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_18_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_18_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_18_matcher::to_string() -> std::string{return R"('$'m)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_18_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_18_matcher::to_string() -> std::string{return R"('$'m)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_180_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_180_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10465,10 +9369,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_180_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_180_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10476,19 +9381,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_180_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_180_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_180_matcher::to_string() -> std::string{return R"('abb$'m)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_180_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_180_matcher::to_string() -> std::string{return R"('abb$'m)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_181_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_181_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10517,10 +9422,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_181_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_181_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10528,19 +9434,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_181_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_181_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_181_matcher::to_string() -> std::string{return R"(abb\Z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_181_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_181_matcher::to_string() -> std::string{return R"(abb\Z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_182_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_182_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10569,10 +9475,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_182_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_182_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10580,19 +9487,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_182_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_182_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_182_matcher::to_string() -> std::string{return R"(abb\z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_182_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_182_matcher::to_string() -> std::string{return R"(abb\z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_183_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_183_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10621,10 +9528,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_183_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_183_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10632,19 +9540,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_183_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_183_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_183_matcher::to_string() -> std::string{return R"(abb$)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_183_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_183_matcher::to_string() -> std::string{return R"(abb$)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_184_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_184_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10673,10 +9581,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_184_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_184_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10684,19 +9593,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_184_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_184_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_184_matcher::to_string() -> std::string{return R"(abb\Z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_184_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_184_matcher::to_string() -> std::string{return R"(abb\Z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_185_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_185_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10725,10 +9634,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_185_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_185_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10736,19 +9646,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_185_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_185_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_185_matcher::to_string() -> std::string{return R"(abb\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_185_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_185_matcher::to_string() -> std::string{return R"(abb\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_186_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_186_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10777,10 +9687,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_186_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_186_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10788,19 +9699,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_186_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_186_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_186_matcher::to_string() -> std::string{return R"(abb$)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_186_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_186_matcher::to_string() -> std::string{return R"(abb$)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_187_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_187_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10829,10 +9740,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_187_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_187_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10840,19 +9752,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_187_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_187_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_187_matcher::to_string() -> std::string{return R"(abb\Z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_187_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_187_matcher::to_string() -> std::string{return R"(abb\Z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_188_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_188_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10881,10 +9793,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_188_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_188_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10892,19 +9805,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_188_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_188_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_188_matcher::to_string() -> std::string{return R"(abb\z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_188_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_188_matcher::to_string() -> std::string{return R"(abb\z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_189_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_189_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10933,10 +9846,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_189_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_189_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10944,19 +9858,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_189_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_189_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_189_matcher::to_string() -> std::string{return R"(abb$)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_189_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_189_matcher::to_string() -> std::string{return R"(abb$)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_19_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_19_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -10985,10 +9899,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_19_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_19_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -10996,19 +9911,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_19_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_19_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_19_matcher::to_string() -> std::string{return R"(a\Z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_19_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_19_matcher::to_string() -> std::string{return R"(a\Z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_190_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_190_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11037,10 +9952,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_190_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_190_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11048,19 +9964,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_190_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_190_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_190_matcher::to_string() -> std::string{return R"('abb\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_190_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_190_matcher::to_string() -> std::string{return R"('abb\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_191_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_191_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11089,10 +10005,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_191_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_191_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11100,19 +10017,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_191_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_191_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_191_matcher::to_string() -> std::string{return R"('abb\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_191_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_191_matcher::to_string() -> std::string{return R"('abb\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_192_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_192_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11141,10 +10058,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_192_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_192_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11152,19 +10070,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_192_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_192_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_192_matcher::to_string() -> std::string{return R"('abb$'m)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_192_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_192_matcher::to_string() -> std::string{return R"('abb$'m)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_193_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_193_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11193,10 +10111,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_193_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_193_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11204,19 +10123,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_193_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_193_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_193_matcher::to_string() -> std::string{return R"('abb\Z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_193_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_193_matcher::to_string() -> std::string{return R"('abb\Z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_194_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_194_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11245,10 +10164,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_194_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_194_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11256,19 +10176,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_194_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_194_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_194_matcher::to_string() -> std::string{return R"('abb\z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_194_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_194_matcher::to_string() -> std::string{return R"('abb\z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_195_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_195_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11297,10 +10217,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_195_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_195_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11308,19 +10229,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_195_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_195_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_195_matcher::to_string() -> std::string{return R"('abb$'m)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_195_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_195_matcher::to_string() -> std::string{return R"('abb$'m)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_196_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_196_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11349,10 +10270,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_196_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_196_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11360,19 +10282,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_196_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_196_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_196_matcher::to_string() -> std::string{return R"('abb\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_196_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_196_matcher::to_string() -> std::string{return R"('abb\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_197_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_197_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11401,10 +10323,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_197_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_197_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11412,19 +10335,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_197_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_197_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_197_matcher::to_string() -> std::string{return R"('abb\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_197_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_197_matcher::to_string() -> std::string{return R"('abb\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_198_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_198_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11453,10 +10376,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_198_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_198_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11464,19 +10388,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_198_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_198_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_198_matcher::to_string() -> std::string{return R"('abb$'m)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_198_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_198_matcher::to_string() -> std::string{return R"('abb$'m)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_199_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_199_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11506,10 +10430,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_199_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_199_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11517,19 +10442,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_199_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_199_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_199_matcher::to_string() -> std::string{return R"('\Aa$'m)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_199_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_199_matcher::to_string() -> std::string{return R"('\Aa$'m)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_20_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_20_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11558,10 +10483,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_20_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_20_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11569,19 +10495,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_20_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_20_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_20_matcher::to_string() -> std::string{return R"(a\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_20_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_20_matcher::to_string() -> std::string{return R"(a\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_21_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_21_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11610,10 +10536,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_21_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_21_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11621,19 +10548,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_21_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_21_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_21_matcher::to_string() -> std::string{return R"(a$)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_21_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_21_matcher::to_string() -> std::string{return R"(a$)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_22_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_22_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11662,10 +10589,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_22_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_22_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11673,19 +10601,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_22_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_22_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_22_matcher::to_string() -> std::string{return R"(a\Z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_22_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_22_matcher::to_string() -> std::string{return R"(a\Z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_23_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_23_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11714,10 +10642,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_23_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_23_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11725,19 +10654,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_23_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_23_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_23_matcher::to_string() -> std::string{return R"(a\z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_23_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_23_matcher::to_string() -> std::string{return R"(a\z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_24_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_24_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11766,10 +10695,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_24_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_24_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11777,19 +10707,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_24_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_24_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_24_matcher::to_string() -> std::string{return R"(a$)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_24_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_24_matcher::to_string() -> std::string{return R"(a$)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_25_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_25_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11818,10 +10748,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_25_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_25_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11829,19 +10760,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_25_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_25_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_25_matcher::to_string() -> std::string{return R"(a\Z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_25_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_25_matcher::to_string() -> std::string{return R"(a\Z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_26_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_26_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11870,10 +10801,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_26_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_26_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11881,19 +10813,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_26_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_26_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_26_matcher::to_string() -> std::string{return R"(a\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_26_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_26_matcher::to_string() -> std::string{return R"(a\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_27_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_27_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11922,10 +10854,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_27_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_27_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11933,19 +10866,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_27_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_27_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_27_matcher::to_string() -> std::string{return R"(a$)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_27_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_27_matcher::to_string() -> std::string{return R"(a$)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_28_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_28_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -11974,10 +10907,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_28_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_28_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -11985,19 +10919,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_28_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_28_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_28_matcher::to_string() -> std::string{return R"('a\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_28_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_28_matcher::to_string() -> std::string{return R"('a\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_29_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_29_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12026,10 +10960,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_29_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_29_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12037,19 +10972,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_29_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_29_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_29_matcher::to_string() -> std::string{return R"('a\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_29_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_29_matcher::to_string() -> std::string{return R"('a\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_30_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_30_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12078,10 +11013,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_30_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_30_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12089,19 +11025,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_30_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_30_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_30_matcher::to_string() -> std::string{return R"('a$'m)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_30_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_30_matcher::to_string() -> std::string{return R"('a$'m)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_31_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_31_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12130,10 +11066,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_31_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_31_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12141,19 +11078,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_31_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_31_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_31_matcher::to_string() -> std::string{return R"('a\Z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_31_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_31_matcher::to_string() -> std::string{return R"('a\Z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_32_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_32_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12182,10 +11119,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_32_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_32_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12193,19 +11131,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_32_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_32_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_32_matcher::to_string() -> std::string{return R"('a\z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_32_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_32_matcher::to_string() -> std::string{return R"('a\z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_33_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_33_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12234,10 +11172,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_33_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_33_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12245,19 +11184,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_33_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_33_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_33_matcher::to_string() -> std::string{return R"('a$'m)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_33_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_33_matcher::to_string() -> std::string{return R"('a$'m)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_34_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_34_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12286,10 +11225,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_34_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_34_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12297,19 +11237,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_34_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_34_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_34_matcher::to_string() -> std::string{return R"('a\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_34_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_34_matcher::to_string() -> std::string{return R"('a\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_35_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_35_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12338,10 +11278,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_35_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_35_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12349,19 +11290,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_35_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_35_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_35_matcher::to_string() -> std::string{return R"('a\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_35_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_35_matcher::to_string() -> std::string{return R"('a\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_36_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_36_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12390,10 +11331,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_36_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_36_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12401,19 +11343,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_36_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_36_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_36_matcher::to_string() -> std::string{return R"('a$'m)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_36_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_36_matcher::to_string() -> std::string{return R"('a$'m)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_37_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_37_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12442,10 +11384,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_37_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_37_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12453,19 +11396,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_37_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_37_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_37_matcher::to_string() -> std::string{return R"(aa\Z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_37_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_37_matcher::to_string() -> std::string{return R"(aa\Z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_38_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_38_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12494,10 +11437,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_38_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_38_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12505,19 +11449,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_38_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_38_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_38_matcher::to_string() -> std::string{return R"(aa\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_38_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_38_matcher::to_string() -> std::string{return R"(aa\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_39_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_39_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12546,10 +11490,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_39_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_39_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12557,19 +11502,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_39_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_39_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_39_matcher::to_string() -> std::string{return R"(aa$)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_39_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_39_matcher::to_string() -> std::string{return R"(aa$)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_40_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_40_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12598,10 +11543,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_40_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_40_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12609,19 +11555,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_40_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_40_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_40_matcher::to_string() -> std::string{return R"(aa\Z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_40_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_40_matcher::to_string() -> std::string{return R"(aa\Z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_41_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_41_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12650,10 +11596,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_41_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_41_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12661,19 +11608,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_41_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_41_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_41_matcher::to_string() -> std::string{return R"(aa\z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_41_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_41_matcher::to_string() -> std::string{return R"(aa\z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_42_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_42_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12702,10 +11649,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_42_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_42_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12713,19 +11661,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_42_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_42_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_42_matcher::to_string() -> std::string{return R"(aa$)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_42_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_42_matcher::to_string() -> std::string{return R"(aa$)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_43_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_43_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12754,10 +11702,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_43_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_43_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12765,19 +11714,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_43_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_43_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_43_matcher::to_string() -> std::string{return R"(aa\Z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_43_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_43_matcher::to_string() -> std::string{return R"(aa\Z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_44_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_44_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12806,10 +11755,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_44_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_44_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12817,19 +11767,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_44_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_44_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_44_matcher::to_string() -> std::string{return R"(aa\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_44_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_44_matcher::to_string() -> std::string{return R"(aa\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_45_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_45_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12858,10 +11808,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_45_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_45_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12869,19 +11820,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_45_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_45_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_45_matcher::to_string() -> std::string{return R"(aa$)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_45_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_45_matcher::to_string() -> std::string{return R"(aa$)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_46_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_46_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12910,10 +11861,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_46_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_46_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12921,19 +11873,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_46_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_46_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_46_matcher::to_string() -> std::string{return R"('aa\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_46_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_46_matcher::to_string() -> std::string{return R"('aa\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_47_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_47_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -12962,10 +11914,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_47_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_47_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -12973,19 +11926,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_47_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_47_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_47_matcher::to_string() -> std::string{return R"('aa\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_47_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_47_matcher::to_string() -> std::string{return R"('aa\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_48_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_48_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13014,10 +11967,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_48_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_48_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13025,19 +11979,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_48_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_48_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_48_matcher::to_string() -> std::string{return R"('aa$'m)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_48_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_48_matcher::to_string() -> std::string{return R"('aa$'m)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_49_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_49_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13066,10 +12020,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_49_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_49_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13077,19 +12032,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_49_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_49_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_49_matcher::to_string() -> std::string{return R"('aa\Z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_49_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_49_matcher::to_string() -> std::string{return R"('aa\Z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_50_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_50_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13118,10 +12073,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_50_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_50_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13129,19 +12085,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_50_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_50_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_50_matcher::to_string() -> std::string{return R"('aa\z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_50_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_50_matcher::to_string() -> std::string{return R"('aa\z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_51_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_51_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13170,10 +12126,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_51_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_51_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13181,19 +12138,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_51_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_51_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_51_matcher::to_string() -> std::string{return R"('aa$'m)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_51_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_51_matcher::to_string() -> std::string{return R"('aa$'m)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_52_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_52_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13222,10 +12179,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_52_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_52_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13233,19 +12191,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_52_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_52_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_52_matcher::to_string() -> std::string{return R"('aa\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_52_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_52_matcher::to_string() -> std::string{return R"('aa\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_53_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_53_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13274,10 +12232,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_53_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_53_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13285,19 +12244,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_53_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_53_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_53_matcher::to_string() -> std::string{return R"('aa\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_53_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_53_matcher::to_string() -> std::string{return R"('aa\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_54_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_54_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13326,10 +12285,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_54_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_54_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13337,19 +12297,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_54_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_54_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_54_matcher::to_string() -> std::string{return R"('aa$'m)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_54_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_54_matcher::to_string() -> std::string{return R"('aa$'m)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_55_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_55_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13378,10 +12338,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_55_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_55_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13389,19 +12350,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_55_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_55_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_55_matcher::to_string() -> std::string{return R"(aa\Z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_55_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_55_matcher::to_string() -> std::string{return R"(aa\Z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_56_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_56_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13430,10 +12391,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_56_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_56_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13441,19 +12403,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_56_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_56_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_56_matcher::to_string() -> std::string{return R"(aa\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_56_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_56_matcher::to_string() -> std::string{return R"(aa\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_57_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_57_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13482,10 +12444,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_57_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_57_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13493,19 +12456,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_57_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_57_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_57_matcher::to_string() -> std::string{return R"(aa$)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_57_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_57_matcher::to_string() -> std::string{return R"(aa$)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_58_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_58_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13534,10 +12497,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_58_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_58_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13545,19 +12509,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_58_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_58_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_58_matcher::to_string() -> std::string{return R"(aa\Z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_58_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_58_matcher::to_string() -> std::string{return R"(aa\Z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_59_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_59_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13586,10 +12550,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_59_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_59_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13597,19 +12562,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_59_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_59_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_59_matcher::to_string() -> std::string{return R"(aa\z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_59_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_59_matcher::to_string() -> std::string{return R"(aa\z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_60_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_60_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13638,10 +12603,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_60_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_60_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13649,19 +12615,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_60_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_60_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_60_matcher::to_string() -> std::string{return R"(aa$)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_60_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_60_matcher::to_string() -> std::string{return R"(aa$)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_61_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_61_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13690,10 +12656,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_61_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_61_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13701,19 +12668,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_61_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_61_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_61_matcher::to_string() -> std::string{return R"(aa\Z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_61_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_61_matcher::to_string() -> std::string{return R"(aa\Z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_62_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_62_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13742,10 +12709,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_62_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_62_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13753,19 +12721,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_62_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_62_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_62_matcher::to_string() -> std::string{return R"(aa\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_62_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_62_matcher::to_string() -> std::string{return R"(aa\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_63_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_63_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13794,10 +12762,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_63_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_63_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13805,19 +12774,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_63_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_63_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_63_matcher::to_string() -> std::string{return R"(aa$)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_63_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_63_matcher::to_string() -> std::string{return R"(aa$)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_64_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_64_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13846,10 +12815,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_64_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_64_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13857,19 +12827,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_64_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_64_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_64_matcher::to_string() -> std::string{return R"('aa\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_64_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_64_matcher::to_string() -> std::string{return R"('aa\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_65_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_65_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13898,10 +12868,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_65_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_65_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13909,19 +12880,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_65_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_65_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_65_matcher::to_string() -> std::string{return R"('aa\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_65_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_65_matcher::to_string() -> std::string{return R"('aa\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_66_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_66_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -13950,10 +12921,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_66_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_66_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -13961,19 +12933,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_66_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_66_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_66_matcher::to_string() -> std::string{return R"('aa$'m)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_66_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_66_matcher::to_string() -> std::string{return R"('aa$'m)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_67_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_67_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14002,10 +12974,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_67_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_67_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14013,19 +12986,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_67_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_67_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_67_matcher::to_string() -> std::string{return R"('aa\Z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_67_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_67_matcher::to_string() -> std::string{return R"('aa\Z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_68_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_68_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14054,10 +13027,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_68_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_68_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14065,19 +13039,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_68_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_68_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_68_matcher::to_string() -> std::string{return R"('aa\z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_68_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_68_matcher::to_string() -> std::string{return R"('aa\z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_69_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_69_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14106,10 +13080,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_69_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_69_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14117,19 +13092,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_69_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_69_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_69_matcher::to_string() -> std::string{return R"('aa$'m)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_69_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_69_matcher::to_string() -> std::string{return R"('aa$'m)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_70_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_70_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14158,10 +13133,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_70_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_70_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14169,19 +13145,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_70_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_70_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_70_matcher::to_string() -> std::string{return R"('aa\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_70_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_70_matcher::to_string() -> std::string{return R"('aa\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_71_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_71_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14210,10 +13186,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_71_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_71_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14221,19 +13198,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_71_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_71_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_71_matcher::to_string() -> std::string{return R"('aa\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_71_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_71_matcher::to_string() -> std::string{return R"('aa\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_72_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_72_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14262,10 +13239,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_72_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_72_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14273,19 +13251,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_72_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_72_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_72_matcher::to_string() -> std::string{return R"('aa$'m)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_72_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_72_matcher::to_string() -> std::string{return R"('aa$'m)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_73_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_73_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14314,10 +13292,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_73_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_73_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14325,19 +13304,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_73_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_73_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_73_matcher::to_string() -> std::string{return R"(aa\Z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_73_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_73_matcher::to_string() -> std::string{return R"(aa\Z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_74_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_74_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14366,10 +13345,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_74_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_74_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14377,19 +13357,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_74_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_74_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_74_matcher::to_string() -> std::string{return R"(aa\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_74_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_74_matcher::to_string() -> std::string{return R"(aa\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_75_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_75_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14418,10 +13398,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_75_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_75_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14429,19 +13410,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_75_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_75_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_75_matcher::to_string() -> std::string{return R"(aa$)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_75_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_75_matcher::to_string() -> std::string{return R"(aa$)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_76_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_76_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14470,10 +13451,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_76_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_76_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14481,19 +13463,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_76_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_76_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_76_matcher::to_string() -> std::string{return R"(aa\Z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_76_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_76_matcher::to_string() -> std::string{return R"(aa\Z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_77_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_77_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14522,10 +13504,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_77_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_77_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14533,19 +13516,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_77_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_77_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_77_matcher::to_string() -> std::string{return R"(aa\z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_77_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_77_matcher::to_string() -> std::string{return R"(aa\z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_78_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_78_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14574,10 +13557,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_78_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_78_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14585,19 +13569,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_78_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_78_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_78_matcher::to_string() -> std::string{return R"(aa$)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_78_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_78_matcher::to_string() -> std::string{return R"(aa$)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_79_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_79_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14626,10 +13610,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_79_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_79_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14637,19 +13622,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_79_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_79_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_79_matcher::to_string() -> std::string{return R"(aa\Z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_79_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_79_matcher::to_string() -> std::string{return R"(aa\Z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_80_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_80_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14678,10 +13663,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_80_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_80_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14689,19 +13675,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_80_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_80_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_80_matcher::to_string() -> std::string{return R"(aa\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_80_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_80_matcher::to_string() -> std::string{return R"(aa\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_81_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_81_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14730,10 +13716,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_81_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_81_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14741,19 +13728,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_81_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_81_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_81_matcher::to_string() -> std::string{return R"(aa$)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_81_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_81_matcher::to_string() -> std::string{return R"(aa$)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_82_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_82_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14782,10 +13769,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_82_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_82_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14793,19 +13781,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_82_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_82_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_82_matcher::to_string() -> std::string{return R"('aa\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_82_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_82_matcher::to_string() -> std::string{return R"('aa\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_83_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_83_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14834,10 +13822,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_83_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_83_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14845,19 +13834,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_83_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_83_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_83_matcher::to_string() -> std::string{return R"('aa\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_83_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_83_matcher::to_string() -> std::string{return R"('aa\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_84_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_84_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14886,10 +13875,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_84_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_84_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14897,19 +13887,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_84_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_84_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_84_matcher::to_string() -> std::string{return R"('aa$'m)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_84_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_84_matcher::to_string() -> std::string{return R"('aa$'m)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_85_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_85_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14938,10 +13928,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_85_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_85_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -14949,19 +13940,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_85_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_85_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_85_matcher::to_string() -> std::string{return R"('aa\Z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_85_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_85_matcher::to_string() -> std::string{return R"('aa\Z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_86_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_86_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -14990,10 +13981,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_86_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_86_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15001,19 +13993,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_86_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_86_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_86_matcher::to_string() -> std::string{return R"('aa\z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_86_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_86_matcher::to_string() -> std::string{return R"('aa\z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_87_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_87_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15042,10 +14034,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_87_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_87_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15053,19 +14046,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_87_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_87_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_87_matcher::to_string() -> std::string{return R"('aa$'m)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_87_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_87_matcher::to_string() -> std::string{return R"('aa$'m)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_88_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_88_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15094,10 +14087,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_88_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_88_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15105,19 +14099,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_88_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_88_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_88_matcher::to_string() -> std::string{return R"('aa\Z'm)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_88_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_88_matcher::to_string() -> std::string{return R"('aa\Z'm)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_89_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_89_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15146,10 +14140,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_89_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_89_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15157,19 +14152,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_89_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_89_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_89_matcher::to_string() -> std::string{return R"('aa\z'm)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_89_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_89_matcher::to_string() -> std::string{return R"('aa\z'm)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_90_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_90_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15198,10 +14193,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_90_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_90_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15209,19 +14205,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_90_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_90_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_90_matcher::to_string() -> std::string{return R"('aa$'m)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_90_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_90_matcher::to_string() -> std::string{return R"('aa$'m)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_91_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_91_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15250,10 +14246,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_91_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_91_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15261,19 +14258,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_91_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_91_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_91_matcher::to_string() -> std::string{return R"(ab\Z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_91_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_91_matcher::to_string() -> std::string{return R"(ab\Z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_92_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_92_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15302,10 +14299,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_92_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_92_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15313,19 +14311,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_92_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_92_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_92_matcher::to_string() -> std::string{return R"(ab\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_92_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_92_matcher::to_string() -> std::string{return R"(ab\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_93_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_93_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15354,10 +14352,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_93_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_93_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15365,19 +14364,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_93_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_93_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_93_matcher::to_string() -> std::string{return R"(ab$)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_93_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_93_matcher::to_string() -> std::string{return R"(ab$)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_94_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_94_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15406,10 +14405,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_94_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_94_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15417,19 +14417,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_94_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_94_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_94_matcher::to_string() -> std::string{return R"(ab\Z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_94_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_94_matcher::to_string() -> std::string{return R"(ab\Z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_95_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_95_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15458,10 +14458,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_95_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_95_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15469,19 +14470,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_95_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_95_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_95_matcher::to_string() -> std::string{return R"(ab\z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_95_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_95_matcher::to_string() -> std::string{return R"(ab\z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_96_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_96_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15510,10 +14511,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_96_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_96_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15521,19 +14523,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_96_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_96_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_96_matcher::to_string() -> std::string{return R"(ab$)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_96_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_96_matcher::to_string() -> std::string{return R"(ab$)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_97_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_97_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15562,10 +14564,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_97_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_97_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15573,19 +14576,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_97_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_97_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_97_matcher::to_string() -> std::string{return R"(ab\Z)"; } - + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_97_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_97_matcher::to_string() -> std::string{return R"(ab\Z)"; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_98_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_98_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15614,10 +14617,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_98_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_98_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15625,19 +14629,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_98_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_98_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_98_matcher::to_string() -> std::string{return R"(ab\z)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_98_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_98_matcher::to_string() -> std::string{return R"(ab\z)"; } - - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_99_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_99_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -15666,10 +14670,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_99_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_99_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -15677,15 +14682,16 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_99_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_99_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_14_multiline_modifier::regex_99_matcher::to_string() -> std::string{return R"(ab$)"; } + template [[nodiscard]] constexpr auto test_tests_14_multiline_modifier::regex_99_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_14_multiline_modifier::regex_99_matcher::to_string() -> std::string{return R"(ab$)"; } -#line 569 "pure2-regex_14_multiline_modifier.cpp2" +#line 570 "pure2-regex_14_multiline_modifier.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_14_multiline_modifier()); } diff --git a/regression-tests/test-results/pure2-regex_15_group_modifiers.cpp b/regression-tests/test-results/pure2-regex_15_group_modifiers.cpp index 4f9b4184df..11bbf4276a 100644 --- a/regression-tests/test-results/pure2-regex_15_group_modifiers.cpp +++ b/regression-tests/test-results/pure2-regex_15_group_modifiers.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_15_group_modifiers.cpp2" -#line 165 "pure2-regex_15_group_modifiers.cpp2" +#line 166 "pure2-regex_15_group_modifiers.cpp2" class test_tests_15_group_modifiers; @@ -18,37 +18,31 @@ class test_tests_15_group_modifiers; #line 1 "pure2-regex_15_group_modifiers.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_15_group_modifiers.cpp2" +#line 113 "pure2-regex_15_group_modifiers.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_15_group_modifiers.cpp2" +#line 125 "pure2-regex_15_group_modifiers.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_15_group_modifiers.cpp2" +#line 166 "pure2-regex_15_group_modifiers.cpp2" class test_tests_15_group_modifiers { -#line 219 "pure2-regex_15_group_modifiers.cpp2" +#line 220 "pure2-regex_15_group_modifiers.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -56,25 +50,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -82,25 +70,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_02 {}; public: class regex_03_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_03_matcher() = default; public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -108,25 +90,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_03 {}; public: class regex_04_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_04_matcher() = default; public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -134,25 +110,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_04 {}; public: class regex_05_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_05_matcher() = default; public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -160,25 +130,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_05 {}; public: class regex_06_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_06_matcher() = default; public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -186,25 +150,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_06 {}; public: class regex_07_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_06 {}; public: template class regex_07_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_07_matcher() = default; public: regex_07_matcher(regex_07_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -212,25 +170,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_07 {}; public: class regex_08_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_07 {}; public: template class regex_08_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_08_matcher() = default; public: regex_08_matcher(regex_08_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -238,25 +190,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_08 {}; public: class regex_09_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_08 {}; public: template class regex_09_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_09_matcher() = default; public: regex_09_matcher(regex_09_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -264,25 +210,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_09 {}; public: class regex_10_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_09 {}; public: template class regex_10_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_10_matcher() = default; public: regex_10_matcher(regex_10_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -290,25 +230,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_10 {}; public: class regex_11_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_10 {}; public: template class regex_11_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_11_matcher() = default; public: regex_11_matcher(regex_11_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -316,25 +250,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_11 {}; public: class regex_12_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_11 {}; public: template class regex_12_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_12_matcher() = default; public: regex_12_matcher(regex_12_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -342,25 +270,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_12 {}; public: class regex_13_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_12 {}; public: template class regex_13_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_13_matcher() = default; public: regex_13_matcher(regex_13_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -368,25 +290,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_13 {}; public: class regex_14_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_13 {}; public: template class regex_14_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_14_matcher() = default; public: regex_14_matcher(regex_14_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -394,25 +310,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_14 {}; public: class regex_15_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_14 {}; public: template class regex_15_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_15_matcher() = default; public: regex_15_matcher(regex_15_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -420,25 +330,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_15 {}; public: class regex_16_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_15 {}; public: template class regex_16_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_16_matcher() = default; public: regex_16_matcher(regex_16_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -446,25 +350,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_16 {}; public: class regex_17_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_16 {}; public: template class regex_17_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_17_matcher() = default; public: regex_17_matcher(regex_17_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -472,25 +370,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_17 {}; public: class regex_18_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_17 {}; public: template class regex_18_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_18_matcher() = default; public: regex_18_matcher(regex_18_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -498,25 +390,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_18 {}; public: class regex_19_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_18 {}; public: template class regex_19_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_19_matcher() = default; public: regex_19_matcher(regex_19_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -524,25 +410,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_19 {}; public: class regex_20_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_19 {}; public: template class regex_20_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_20_matcher() = default; public: regex_20_matcher(regex_20_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -550,25 +430,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_20 {}; public: class regex_21_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_20 {}; public: template class regex_21_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_21_matcher() = default; public: regex_21_matcher(regex_21_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -576,25 +450,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_21 {}; public: class regex_22_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_21 {}; public: template class regex_22_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_22_matcher() = default; public: regex_22_matcher(regex_22_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -602,25 +470,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_22 {}; public: class regex_23_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_22 {}; public: template class regex_23_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_23_matcher() = default; public: regex_23_matcher(regex_23_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -628,25 +490,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_23 {}; public: class regex_24_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_23 {}; public: template class regex_24_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_24_matcher() = default; public: regex_24_matcher(regex_24_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -654,25 +510,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_24 {}; public: class regex_25_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_24 {}; public: template class regex_25_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_25_matcher() = default; public: regex_25_matcher(regex_25_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -680,25 +530,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_25 {}; public: class regex_26_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_25 {}; public: template class regex_26_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_26_matcher() = default; public: regex_26_matcher(regex_26_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -706,25 +550,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_26 {}; public: class regex_27_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_26 {}; public: template class regex_27_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_27_matcher() = default; public: regex_27_matcher(regex_27_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -732,25 +570,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_27 {}; public: class regex_28_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_27 {}; public: template class regex_28_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_28_matcher() = default; public: regex_28_matcher(regex_28_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -758,25 +590,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_28 {}; public: class regex_29_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_28 {}; public: template class regex_29_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_29_matcher() = default; public: regex_29_matcher(regex_29_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -784,25 +610,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_29 {}; public: class regex_30_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_29 {}; public: template class regex_30_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_30_matcher() = default; public: regex_30_matcher(regex_30_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -810,25 +630,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_30 {}; public: class regex_31_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_30 {}; public: template class regex_31_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_31_matcher() = default; public: regex_31_matcher(regex_31_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -836,25 +650,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_31 {}; public: class regex_32_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_31 {}; public: template class regex_32_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_32_matcher() = default; public: regex_32_matcher(regex_32_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -862,25 +670,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_32 {}; public: class regex_33_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_32 {}; public: template class regex_33_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_33_matcher() = default; public: regex_33_matcher(regex_33_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -888,25 +690,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_33 {}; public: class regex_34_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_33 {}; public: template class regex_34_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_34_matcher() = default; public: regex_34_matcher(regex_34_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -914,25 +710,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_34 {}; public: class regex_35_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_34 {}; public: template class regex_35_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_35_matcher() = default; public: regex_35_matcher(regex_35_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -940,25 +730,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_35 {}; public: class regex_36_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_35 {}; public: template class regex_36_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_36_matcher() = default; public: regex_36_matcher(regex_36_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -966,25 +750,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_36 {}; public: class regex_37_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_36 {}; public: template class regex_37_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_37_matcher() = default; public: regex_37_matcher(regex_37_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -992,25 +770,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_37 {}; public: class regex_38_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_37 {}; public: template class regex_38_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_38_matcher() = default; public: regex_38_matcher(regex_38_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1018,25 +790,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_38 {}; public: class regex_39_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_38 {}; public: template class regex_39_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_39_matcher() = default; public: regex_39_matcher(regex_39_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1044,25 +810,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_39 {}; public: class regex_40_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_39 {}; public: template class regex_40_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_40_matcher() = default; public: regex_40_matcher(regex_40_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1070,55 +830,49 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_40 {}; public: class regex_41_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_40 {}; public: template class regex_41_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_41_matcher() = default; public: regex_41_matcher(regex_41_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1126,25 +880,19 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_41 {}; public: class regex_42_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_41 {}; public: template class regex_42_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_42_matcher() = default; public: regex_42_matcher(regex_42_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1152,25 +900,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_42 {}; public: class regex_43_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_42 {}; public: template class regex_43_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_43_matcher() = default; public: regex_43_matcher(regex_43_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1178,25 +920,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_43 {}; public: class regex_44_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_43 {}; public: template class regex_44_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_44_matcher() = default; public: regex_44_matcher(regex_44_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1204,25 +940,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_44 {}; public: class regex_45_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_44 {}; public: template class regex_45_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_45_matcher() = default; public: regex_45_matcher(regex_45_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1230,25 +960,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_45 {}; public: class regex_46_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_45 {}; public: template class regex_46_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_46_matcher() = default; public: regex_46_matcher(regex_46_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1256,25 +980,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_46 {}; public: class regex_47_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_46 {}; public: template class regex_47_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_47_matcher() = default; public: regex_47_matcher(regex_47_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1282,25 +1000,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_47 {}; public: class regex_48_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_47 {}; public: template class regex_48_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_48_matcher() = default; public: regex_48_matcher(regex_48_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1308,25 +1020,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_48 {}; public: class regex_49_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_48 {}; public: template class regex_49_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_49_matcher() = default; public: regex_49_matcher(regex_49_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1334,25 +1040,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_49 {}; public: class regex_50_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_49 {}; public: template class regex_50_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_50_matcher() = default; public: regex_50_matcher(regex_50_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1360,25 +1060,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_50 {}; public: class regex_51_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_50 {}; public: template class regex_51_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_51_matcher() = default; public: regex_51_matcher(regex_51_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1386,25 +1080,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_51 {}; public: class regex_52_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_51 {}; public: template class regex_52_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_52_matcher() = default; public: regex_52_matcher(regex_52_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1412,25 +1100,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_52 {}; public: class regex_53_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_52 {}; public: template class regex_53_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_53_matcher() = default; public: regex_53_matcher(regex_53_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1438,13 +1120,13 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_53 {}; + public: cpp2::regex::regular_expression> regex_53 {}; public: test_tests_15_group_modifiers() = default; public: test_tests_15_group_modifiers(test_tests_15_group_modifiers const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_15_group_modifiers const&) -> void = delete; -#line 276 "pure2-regex_15_group_modifiers.cpp2" +#line 277 "pure2-regex_15_group_modifiers.cpp2" }; auto main() -> int; @@ -1548,6 +1230,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -1563,7 +1246,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_15_group_modifiers.cpp2" +#line 113 "pure2-regex_15_group_modifiers.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -1576,7 +1259,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_15_group_modifiers.cpp2" +#line 125 "pure2-regex_15_group_modifiers.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -1617,7 +1300,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 219 "pure2-regex_15_group_modifiers.cpp2" +#line 220 "pure2-regex_15_group_modifiers.cpp2" auto test_tests_15_group_modifiers::run() const& -> void{ std::cout << "Running tests_15_group_modifiers:" << std::endl; test(regex_01, "01", R"((?:(?i)a)b)", "ab", "y", R"($&)", "ab"); @@ -1679,8 +1362,7 @@ template auto test(M const& regex, cpp2::impl::in id, c - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1724,10 +1406,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1735,19 +1418,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_01_matcher::to_string() -> std::string{return R"((?:(?i)a)b)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_01_matcher::to_string() -> std::string{return R"((?:(?i)a)b)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1804,10 +1487,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1815,19 +1499,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_02_matcher::to_string() -> std::string{return R"(((?i)a)b)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_02_matcher::to_string() -> std::string{return R"(((?i)a)b)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_03_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1871,10 +1555,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_03_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1882,19 +1567,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_03_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_03_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_03_matcher::to_string() -> std::string{return R"((?:(?i)a)b)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_03_matcher::to_string() -> std::string{return R"((?:(?i)a)b)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_04_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1951,10 +1636,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_04_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1962,19 +1648,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_04_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_04_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_04_matcher::to_string() -> std::string{return R"(((?i)a)b)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_04_matcher::to_string() -> std::string{return R"(((?i)a)b)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_05_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2018,10 +1704,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_05_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2029,19 +1716,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_05_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_05_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_05_matcher::to_string() -> std::string{return R"((?:(?i)a)b)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_05_matcher::to_string() -> std::string{return R"((?:(?i)a)b)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_06_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2098,10 +1785,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_06_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2109,19 +1797,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_06_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_06_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_06_matcher::to_string() -> std::string{return R"(((?i)a)b)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_06_matcher::to_string() -> std::string{return R"(((?i)a)b)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_07_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_07_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2165,10 +1853,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_07_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_07_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2176,19 +1865,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_07_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_07_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_07_matcher::to_string() -> std::string{return R"((?i:a)b)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_07_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_07_matcher::to_string() -> std::string{return R"((?i:a)b)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_08_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_08_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2245,10 +1934,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_08_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_08_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2256,19 +1946,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_08_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_08_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_08_matcher::to_string() -> std::string{return R"(((?i:a))b)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_08_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_08_matcher::to_string() -> std::string{return R"(((?i:a))b)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_09_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_09_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2312,10 +2002,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_09_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_09_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2323,19 +2014,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_09_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_09_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_09_matcher::to_string() -> std::string{return R"((?i:a)b)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_09_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_09_matcher::to_string() -> std::string{return R"((?i:a)b)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_10_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_10_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2392,10 +2083,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_10_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_10_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2403,19 +2095,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_10_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_10_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_10_matcher::to_string() -> std::string{return R"(((?i:a))b)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_10_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_10_matcher::to_string() -> std::string{return R"(((?i:a))b)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_11_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_11_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2459,10 +2151,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_11_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_11_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2470,19 +2163,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_11_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_11_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_11_matcher::to_string() -> std::string{return R"((?i:a)b)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_11_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_11_matcher::to_string() -> std::string{return R"((?i:a)b)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_12_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_12_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2539,10 +2232,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_12_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_12_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2550,19 +2244,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_12_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_12_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_12_matcher::to_string() -> std::string{return R"(((?i:a))b)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_12_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_12_matcher::to_string() -> std::string{return R"(((?i:a))b)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_13_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_13_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2606,10 +2300,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_13_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_13_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2617,19 +2312,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_13_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_13_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_13_matcher::to_string() -> std::string{return R"('(?:(?-i)a)b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_13_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_13_matcher::to_string() -> std::string{return R"('(?:(?-i)a)b'i)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_14_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_14_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2686,10 +2381,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_14_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_14_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2697,19 +2393,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_14_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_14_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_14_matcher::to_string() -> std::string{return R"('((?-i)a)b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_14_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_14_matcher::to_string() -> std::string{return R"('((?-i)a)b'i)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_15_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_15_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2753,10 +2449,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_15_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_15_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2764,19 +2461,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_15_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_15_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_15_matcher::to_string() -> std::string{return R"('(?:(?-i)a)b'i)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_15_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_15_matcher::to_string() -> std::string{return R"('(?:(?-i)a)b'i)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_16_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_16_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2833,10 +2530,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_16_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_16_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2844,19 +2542,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_16_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_16_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_16_matcher::to_string() -> std::string{return R"('((?-i)a)b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_16_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_16_matcher::to_string() -> std::string{return R"('((?-i)a)b'i)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_17_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_17_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2900,10 +2598,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_17_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_17_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2911,19 +2610,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_17_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_17_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_17_matcher::to_string() -> std::string{return R"('(?:(?-i)a)b'i)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_17_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_17_matcher::to_string() -> std::string{return R"('(?:(?-i)a)b'i)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_18_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_18_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2980,10 +2679,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_18_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_18_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2991,19 +2691,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_18_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_18_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_18_matcher::to_string() -> std::string{return R"('((?-i)a)b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_18_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_18_matcher::to_string() -> std::string{return R"('((?-i)a)b'i)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_19_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_19_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3047,10 +2747,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_19_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_19_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3058,19 +2759,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_19_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_19_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_19_matcher::to_string() -> std::string{return R"('(?:(?-i)a)b'i)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_19_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_19_matcher::to_string() -> std::string{return R"('(?:(?-i)a)b'i)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_20_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_20_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3127,10 +2828,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_20_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_20_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3138,19 +2840,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_20_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_20_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_20_matcher::to_string() -> std::string{return R"('((?-i)a)b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_20_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_20_matcher::to_string() -> std::string{return R"('((?-i)a)b'i)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_21_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_21_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3194,10 +2896,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_21_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_21_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3205,19 +2908,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_21_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_21_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_21_matcher::to_string() -> std::string{return R"('(?:(?-i)a)b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_21_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_21_matcher::to_string() -> std::string{return R"('(?:(?-i)a)b'i)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_22_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_22_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3274,10 +2977,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_22_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_22_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3285,19 +2989,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_22_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_22_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_22_matcher::to_string() -> std::string{return R"('((?-i)a)b'i)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_22_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_22_matcher::to_string() -> std::string{return R"('((?-i)a)b'i)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_23_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_23_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3341,10 +3045,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_23_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_23_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3352,19 +3057,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_23_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_23_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_23_matcher::to_string() -> std::string{return R"('(?-i:a)b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_23_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_23_matcher::to_string() -> std::string{return R"('(?-i:a)b'i)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_24_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_24_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3421,10 +3126,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_24_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_24_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3432,19 +3138,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_24_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_24_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_24_matcher::to_string() -> std::string{return R"('((?-i:a))b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_24_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_24_matcher::to_string() -> std::string{return R"('((?-i:a))b'i)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_25_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_25_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3488,10 +3194,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_25_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_25_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3499,19 +3206,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_25_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_25_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_25_matcher::to_string() -> std::string{return R"('(?-i:a)b'i)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_25_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_25_matcher::to_string() -> std::string{return R"('(?-i:a)b'i)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_26_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_26_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3568,10 +3275,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_26_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_26_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3579,19 +3287,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_26_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_26_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_26_matcher::to_string() -> std::string{return R"('((?-i:a))b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_26_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_26_matcher::to_string() -> std::string{return R"('((?-i:a))b'i)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_27_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_27_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3635,10 +3343,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_27_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_27_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3646,19 +3355,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_27_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_27_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_27_matcher::to_string() -> std::string{return R"('(?-i:a)b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_27_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_27_matcher::to_string() -> std::string{return R"('(?-i:a)b'i)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_28_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_28_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3715,10 +3424,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_28_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_28_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3726,19 +3436,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_28_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_28_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_28_matcher::to_string() -> std::string{return R"('((?-i:a))b'i)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_28_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_28_matcher::to_string() -> std::string{return R"('((?-i:a))b'i)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_29_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_29_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3782,10 +3492,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_29_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_29_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3793,19 +3504,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_29_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_29_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_29_matcher::to_string() -> std::string{return R"('(?-i:a)b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_29_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_29_matcher::to_string() -> std::string{return R"('(?-i:a)b'i)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_30_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_30_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3862,10 +3573,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_30_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_30_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3873,19 +3585,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_30_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_30_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_30_matcher::to_string() -> std::string{return R"('((?-i:a))b'i)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_30_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_30_matcher::to_string() -> std::string{return R"('((?-i:a))b'i)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_31_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_31_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3929,10 +3641,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_31_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_31_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3940,19 +3653,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_31_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_31_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_31_matcher::to_string() -> std::string{return R"('(?-i:a)b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_31_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_31_matcher::to_string() -> std::string{return R"('(?-i:a)b'i)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_32_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_32_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4009,10 +3722,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_32_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_32_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4020,19 +3734,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_32_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_32_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_32_matcher::to_string() -> std::string{return R"('((?-i:a))b'i)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_32_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_32_matcher::to_string() -> std::string{return R"('((?-i:a))b'i)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_33_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_33_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4090,10 +3804,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_33_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_33_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4101,19 +3816,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_33_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_33_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_33_matcher::to_string() -> std::string{return R"('((?-i:a.))b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_33_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_33_matcher::to_string() -> std::string{return R"('((?-i:a.))b'i)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_34_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_34_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4171,10 +3886,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_34_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_34_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4182,19 +3898,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_34_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_34_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_34_matcher::to_string() -> std::string{return R"('((?-i:a\N))b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_34_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_34_matcher::to_string() -> std::string{return R"('((?-i:a\N))b'i)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_35_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_35_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4252,10 +3968,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_35_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_35_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4263,19 +3980,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_35_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_35_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_35_matcher::to_string() -> std::string{return R"('((?s-i:a.))b'i)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_35_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_35_matcher::to_string() -> std::string{return R"('((?s-i:a.))b'i)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_36_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_36_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4333,10 +4050,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_36_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_36_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4344,19 +4062,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_36_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_36_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_36_matcher::to_string() -> std::string{return R"('((?s-i:a\N))b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_36_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_36_matcher::to_string() -> std::string{return R"('((?s-i:a\N))b'i)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_37_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_37_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4414,10 +4132,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_37_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_37_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4425,19 +4144,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_37_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_37_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_37_matcher::to_string() -> std::string{return R"('((?s-i:a.))b'i)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_37_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_37_matcher::to_string() -> std::string{return R"('((?s-i:a.))b'i)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_38_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_38_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4495,10 +4214,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_38_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_38_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4506,19 +4226,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_38_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_38_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_38_matcher::to_string() -> std::string{return R"('((?s-i:a\N))b'i)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_38_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_38_matcher::to_string() -> std::string{return R"('((?s-i:a\N))b'i)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_39_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_39_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4535,10 +4255,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_39_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_39_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4546,19 +4267,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_39_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_39_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_39_matcher::to_string() -> std::string{return R"((?i:.[b].))"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_39_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_39_matcher::to_string() -> std::string{return R"((?i:.[b].))"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_40_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_40_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4575,10 +4296,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_40_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_40_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4586,19 +4308,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_40_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_40_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_40_matcher::to_string() -> std::string{return R"((?i:\N[b]\N))"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_40_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_40_matcher::to_string() -> std::string{return R"((?i:\N[b]\N))"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4626,11 +4348,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4644,11 +4367,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4676,11 +4400,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4694,11 +4419,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4712,11 +4438,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4731,11 +4458,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4750,10 +4478,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4761,19 +4490,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::to_string() -> std::string{return R"(^(?:a?b?)*$)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_41_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_41_matcher::to_string() -> std::string{return R"(^(?:a?b?)*$)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_42_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_42_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4858,10 +4587,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_42_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_42_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4869,19 +4599,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_42_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_42_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_42_matcher::to_string() -> std::string{return R"(((?s)^a(.))((?m)^b$))"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_42_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_42_matcher::to_string() -> std::string{return R"(((?s)^a(.))((?m)^b$))"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_43_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_43_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4924,10 +4654,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_43_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_43_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4935,19 +4666,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_43_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_43_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_43_matcher::to_string() -> std::string{return R"(((?m)^b$))"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_43_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_43_matcher::to_string() -> std::string{return R"(((?m)^b$))"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_44_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_44_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4976,10 +4707,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_44_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_44_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4987,19 +4719,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_44_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_44_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_44_matcher::to_string() -> std::string{return R"((?m)^b)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_44_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_44_matcher::to_string() -> std::string{return R"((?m)^b)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_45_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_45_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5041,10 +4773,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_45_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_45_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5052,19 +4785,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_45_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_45_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_45_matcher::to_string() -> std::string{return R"((?m)^(b))"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_45_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_45_matcher::to_string() -> std::string{return R"((?m)^(b))"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_46_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_46_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5106,10 +4839,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_46_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_46_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5117,19 +4851,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_46_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_46_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_46_matcher::to_string() -> std::string{return R"(((?m)^b))"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_46_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_46_matcher::to_string() -> std::string{return R"(((?m)^b))"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_47_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_47_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5185,10 +4919,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_47_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_47_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5196,19 +4931,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_47_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_47_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_47_matcher::to_string() -> std::string{return R"(\n((?m)^b))"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_47_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_47_matcher::to_string() -> std::string{return R"(\n((?m)^b))"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_48_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_48_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5237,10 +4972,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_48_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_48_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5248,19 +4984,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_48_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_48_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_48_matcher::to_string() -> std::string{return R"(^b)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_48_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_48_matcher::to_string() -> std::string{return R"(^b)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_49_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_49_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5302,10 +5038,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_49_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_49_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5313,19 +5050,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_49_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_49_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_49_matcher::to_string() -> std::string{return R"(()^b)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_49_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_49_matcher::to_string() -> std::string{return R"(()^b)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_50_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_50_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5367,10 +5104,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_50_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_50_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5378,19 +5116,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_50_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_50_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_50_matcher::to_string() -> std::string{return R"(((?m)^b))"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_50_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_50_matcher::to_string() -> std::string{return R"(((?m)^b))"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_51_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_51_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5418,10 +5156,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_51_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_51_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5429,19 +5168,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_51_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_51_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_51_matcher::to_string() -> std::string{return R"('(?:foo)'n)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_51_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_51_matcher::to_string() -> std::string{return R"('(?:foo)'n)"; } - - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_52_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_52_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5496,10 +5235,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_52_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_52_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5507,19 +5247,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_52_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_52_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_52_matcher::to_string() -> std::string{return R"('(?-n)(foo)(?n)(?:bar)'n)"; } - + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_52_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_52_matcher::to_string() -> std::string{return R"('(?-n)(foo)(?n)(?:bar)'n)"; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_53_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_53_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5574,10 +5314,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_53_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_15_group_modifiers::regex_53_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5585,15 +5326,16 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_15_group_modifiers::regex_53_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_15_group_modifiers::regex_53_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_15_group_modifiers::regex_53_matcher::to_string() -> std::string{return R"('(?-n:(foo)(?n:(?:bar)))'n)"; } + template [[nodiscard]] constexpr auto test_tests_15_group_modifiers::regex_53_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_15_group_modifiers::regex_53_matcher::to_string() -> std::string{return R"('(?-n:(foo)(?n:(?:bar)))'n)"; } -#line 277 "pure2-regex_15_group_modifiers.cpp2" +#line 278 "pure2-regex_15_group_modifiers.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_15_group_modifiers()); } diff --git a/regression-tests/test-results/pure2-regex_16_perl_syntax_modifier.cpp b/regression-tests/test-results/pure2-regex_16_perl_syntax_modifier.cpp index 70cf7703bf..a545bf3c2a 100644 --- a/regression-tests/test-results/pure2-regex_16_perl_syntax_modifier.cpp +++ b/regression-tests/test-results/pure2-regex_16_perl_syntax_modifier.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_16_perl_syntax_modifier.cpp2" -#line 165 "pure2-regex_16_perl_syntax_modifier.cpp2" +#line 166 "pure2-regex_16_perl_syntax_modifier.cpp2" class test_tests_16_perl_syntax_modifier; @@ -18,47 +18,41 @@ class test_tests_16_perl_syntax_modifier; #line 1 "pure2-regex_16_perl_syntax_modifier.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_16_perl_syntax_modifier.cpp2" +#line 113 "pure2-regex_16_perl_syntax_modifier.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_16_perl_syntax_modifier.cpp2" +#line 125 "pure2-regex_16_perl_syntax_modifier.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_16_perl_syntax_modifier.cpp2" +#line 166 "pure2-regex_16_perl_syntax_modifier.cpp2" class test_tests_16_perl_syntax_modifier { -#line 199 "pure2-regex_16_perl_syntax_modifier.cpp2" +#line 200 "pure2-regex_16_perl_syntax_modifier.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -66,35 +60,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -102,35 +90,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_02 {}; public: class regex_03_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_03_matcher() = default; public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -138,35 +120,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_03 {}; public: class regex_04_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_04_matcher() = default; public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -174,35 +150,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_04 {}; public: class regex_05_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_05_matcher() = default; public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -210,35 +180,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_05 {}; public: class regex_06_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_06_matcher() = default; public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -246,25 +210,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_06 {}; public: class regex_07_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_06 {}; public: template class regex_07_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_07_matcher() = default; public: regex_07_matcher(regex_07_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -272,35 +230,29 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_07 {}; public: class regex_08_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_07 {}; public: template class regex_08_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_08_matcher() = default; public: regex_08_matcher(regex_08_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -308,35 +260,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_08 {}; public: class regex_09_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_08 {}; public: template class regex_09_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_09_matcher() = default; public: regex_09_matcher(regex_09_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -344,25 +290,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_09 {}; public: class regex_10_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_09 {}; public: template class regex_10_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_10_matcher() = default; public: regex_10_matcher(regex_10_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -370,25 +310,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_10 {}; public: class regex_11_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_10 {}; public: template class regex_11_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_11_matcher() = default; public: regex_11_matcher(regex_11_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -396,25 +330,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_11 {}; public: class regex_12_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_11 {}; public: template class regex_12_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_12_matcher() = default; public: regex_12_matcher(regex_12_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -422,25 +350,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_12 {}; public: class regex_13_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_12 {}; public: template class regex_13_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_13_matcher() = default; public: regex_13_matcher(regex_13_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -448,25 +370,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_13 {}; public: class regex_14_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_13 {}; public: template class regex_14_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_14_matcher() = default; public: regex_14_matcher(regex_14_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -474,25 +390,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_14 {}; public: class regex_15_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_14 {}; public: template class regex_15_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_15_matcher() = default; public: regex_15_matcher(regex_15_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -500,25 +410,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_15 {}; public: class regex_16_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_15 {}; public: template class regex_16_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_16_matcher() = default; public: regex_16_matcher(regex_16_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -526,25 +430,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_16 {}; public: class regex_17_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_16 {}; public: template class regex_17_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_17_matcher() = default; public: regex_17_matcher(regex_17_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -552,25 +450,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_17 {}; public: class regex_18_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_17 {}; public: template class regex_18_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_18_matcher() = default; public: regex_18_matcher(regex_18_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -578,25 +470,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_18 {}; public: class regex_19_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_18 {}; public: template class regex_19_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_19_matcher() = default; public: regex_19_matcher(regex_19_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -604,25 +490,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_19 {}; public: class regex_20_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_19 {}; public: template class regex_20_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_20_matcher() = default; public: regex_20_matcher(regex_20_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -630,35 +510,29 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_20 {}; public: class regex_21_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_20 {}; public: template class regex_21_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_21_matcher() = default; public: regex_21_matcher(regex_21_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -666,35 +540,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_21 {}; public: class regex_22_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_21 {}; public: template class regex_22_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_22_matcher() = default; public: regex_22_matcher(regex_22_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -702,35 +570,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_22 {}; public: class regex_23_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_22 {}; public: template class regex_23_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_23_matcher() = default; public: regex_23_matcher(regex_23_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -738,35 +600,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_23 {}; public: class regex_24_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_23 {}; public: template class regex_24_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_24_matcher() = default; public: regex_24_matcher(regex_24_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -774,35 +630,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_24 {}; public: class regex_25_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_24 {}; public: template class regex_25_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_25_matcher() = default; public: regex_25_matcher(regex_25_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -810,35 +660,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_25 {}; public: class regex_26_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_25 {}; public: template class regex_26_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_26_matcher() = default; public: regex_26_matcher(regex_26_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -846,25 +690,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_26 {}; public: class regex_27_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_26 {}; public: template class regex_27_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_27_matcher() = default; public: regex_27_matcher(regex_27_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -872,35 +710,29 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_27 {}; public: class regex_28_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_27 {}; public: template class regex_28_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_28_matcher() = default; public: regex_28_matcher(regex_28_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -908,35 +740,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_28 {}; public: class regex_29_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_28 {}; public: template class regex_29_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_29_matcher() = default; public: regex_29_matcher(regex_29_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -944,25 +770,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_29 {}; public: class regex_30_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_29 {}; public: template class regex_30_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_30_matcher() = default; public: regex_30_matcher(regex_30_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -970,25 +790,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_30 {}; public: class regex_31_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_30 {}; public: template class regex_31_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_31_matcher() = default; public: regex_31_matcher(regex_31_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -996,25 +810,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_31 {}; public: class regex_32_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_31 {}; public: template class regex_32_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_32_matcher() = default; public: regex_32_matcher(regex_32_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1022,25 +830,19 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_32 {}; public: class regex_33_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_32 {}; public: template class regex_33_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_33_matcher() = default; public: regex_33_matcher(regex_33_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1048,13 +850,13 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_33 {}; + public: cpp2::regex::regular_expression> regex_33 {}; public: test_tests_16_perl_syntax_modifier() = default; public: test_tests_16_perl_syntax_modifier(test_tests_16_perl_syntax_modifier const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_16_perl_syntax_modifier const&) -> void = delete; -#line 236 "pure2-regex_16_perl_syntax_modifier.cpp2" +#line 237 "pure2-regex_16_perl_syntax_modifier.cpp2" }; auto main() -> int; @@ -1158,6 +960,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -1173,7 +976,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_16_perl_syntax_modifier.cpp2" +#line 113 "pure2-regex_16_perl_syntax_modifier.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -1186,7 +989,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_16_perl_syntax_modifier.cpp2" +#line 125 "pure2-regex_16_perl_syntax_modifier.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -1227,7 +1030,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 199 "pure2-regex_16_perl_syntax_modifier.cpp2" +#line 200 "pure2-regex_16_perl_syntax_modifier.cpp2" auto test_tests_16_perl_syntax_modifier::run() const& -> void{ std::cout << "Running tests_16_perl_syntax_modifier:" << std::endl; test(regex_01, "01", R"(/\N {1}/x)", "abbbbc", "y", R"($&)", "a"); @@ -1269,8 +1072,7 @@ template auto test(M const& regex, cpp2::impl::in id, c - - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_01_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_01_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1285,11 +1087,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1303,11 +1106,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_01_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_01_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1321,10 +1125,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1332,19 +1137,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_01_matcher::to_string() -> std::string{return R"(/\N{1}/x)"; } + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_01_matcher::to_string() -> std::string{return R"(/\N{1}/x)"; } - - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_02_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_02_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1359,11 +1164,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1377,11 +1183,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_02_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_02_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1395,10 +1202,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1406,19 +1214,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_02_matcher::to_string() -> std::string{return R"(/\N{1}/x)"; } - + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_02_matcher::to_string() -> std::string{return R"(/\N{1}/x)"; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_03_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_03_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1433,11 +1241,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_03_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1451,11 +1260,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_03_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_03_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1469,10 +1279,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_03_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1480,19 +1291,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_03_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_03_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_03_matcher::to_string() -> std::string{return R"(/\N{1}/x)"; } - + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_03_matcher::to_string() -> std::string{return R"(/\N{1}/x)"; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_04_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_04_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1507,11 +1318,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_04_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1525,11 +1337,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_04_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_04_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1543,10 +1356,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_04_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1554,19 +1368,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_04_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_04_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_04_matcher::to_string() -> std::string{return R"(/\N{3,4}/x)"; } + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_04_matcher::to_string() -> std::string{return R"(/\N{3,4}/x)"; } - - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_05_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_05_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1581,11 +1395,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_05_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1599,11 +1414,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_05_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_05_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1617,10 +1433,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_05_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1628,19 +1445,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_05_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_05_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_05_matcher::to_string() -> std::string{return R"(/\N{3,4}/x)"; } - + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_05_matcher::to_string() -> std::string{return R"(/\N{3,4}/x)"; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_06_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_06_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1655,11 +1472,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_06_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1673,11 +1491,12 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_06_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_06_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1691,10 +1510,11 @@ template auto test(M const& regex, cpp2::impl::in id, c else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_06_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1702,19 +1522,19 @@ template auto test(M const& regex, cpp2::impl::in id, c return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_06_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_06_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_06_matcher::to_string() -> std::string{return R"(/\N{3,4}/x)"; } + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_06_matcher::to_string() -> std::string{return R"(/\N{3,4}/x)"; } - - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_07_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_07_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1757,10 +1577,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_07_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_07_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1768,19 +1589,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_07_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_07_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_07_matcher::to_string() -> std::string{return R"(/a\Nc/x)"; } - + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_07_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_07_matcher::to_string() -> std::string{return R"(/a\Nc/x)"; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_08_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_08_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1795,11 +1616,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_08_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_08_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1827,11 +1649,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_08_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_08_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1859,10 +1682,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_08_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_08_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1870,19 +1694,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_08_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_08_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_08_matcher::to_string() -> std::string{return R"(/a\N*c/x)"; } + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_08_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_08_matcher::to_string() -> std::string{return R"(/a\N*c/x)"; } - - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_09_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_09_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1897,11 +1721,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_09_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_09_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1929,11 +1754,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_09_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_09_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1961,10 +1787,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_09_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_09_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1972,19 +1799,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_09_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_09_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_09_matcher::to_string() -> std::string{return R"(/a\N*c/x)"; } - + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_09_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_09_matcher::to_string() -> std::string{return R"(/a\N*c/x)"; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_10_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_10_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1999,10 +1826,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_10_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_10_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2010,19 +1838,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_10_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_10_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_10_matcher::to_string() -> std::string{return R"(/[a b]/x)"; } + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_10_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_10_matcher::to_string() -> std::string{return R"(/[a b]/x)"; } - - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_11_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_11_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2037,10 +1865,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_11_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_11_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2048,19 +1877,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_11_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_11_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_11_matcher::to_string() -> std::string{return R"(/[a b]/xx)"; } - + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_11_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_11_matcher::to_string() -> std::string{return R"(/[a b]/xx)"; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_12_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_12_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2075,10 +1904,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_12_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_12_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2086,19 +1916,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_12_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_12_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_12_matcher::to_string() -> std::string{return R"(/[a\ b]/xx)"; } + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_12_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_12_matcher::to_string() -> std::string{return R"(/[a\ b]/xx)"; } - - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_13_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_13_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2113,10 +1943,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_13_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_13_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2124,19 +1955,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_13_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_13_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_13_matcher::to_string() -> std::string{return R"(/[ ^ a b ]/xx)"; } - + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_13_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_13_matcher::to_string() -> std::string{return R"(/[ ^ a b ]/xx)"; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_14_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_14_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2151,10 +1982,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_14_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_14_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2162,19 +1994,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_14_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_14_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_14_matcher::to_string() -> std::string{return R"(/[ ^ a b ]/xx)"; } + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_14_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_14_matcher::to_string() -> std::string{return R"(/[ ^ a b ]/xx)"; } - - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_15_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_15_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2189,10 +2021,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_15_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_15_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2200,19 +2033,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_15_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_15_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_15_matcher::to_string() -> std::string{return R"(/[ ^ a b ]/xx)"; } - + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_15_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_15_matcher::to_string() -> std::string{return R"(/[ ^ a b ]/xx)"; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_16_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_16_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2227,10 +2060,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_16_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_16_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2238,19 +2072,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_16_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_16_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_16_matcher::to_string() -> std::string{return R"(/(?x:[a b])/xx)"; } + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_16_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_16_matcher::to_string() -> std::string{return R"(/(?x:[a b])/xx)"; } - - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_17_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_17_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2265,10 +2099,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_17_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_17_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2276,19 +2111,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_17_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_17_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_17_matcher::to_string() -> std::string{return R"(/(?xx:[a b])/x)"; } - + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_17_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_17_matcher::to_string() -> std::string{return R"(/(?xx:[a b])/x)"; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_18_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_18_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2303,10 +2138,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_18_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_18_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2314,19 +2150,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_18_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_18_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_18_matcher::to_string() -> std::string{return R"(/(?x)[a b]/xx)"; } + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_18_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_18_matcher::to_string() -> std::string{return R"(/(?x)[a b]/xx)"; } - - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_19_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_19_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2341,10 +2177,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_19_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_19_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2352,19 +2189,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_19_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_19_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_19_matcher::to_string() -> std::string{return R"(/(?xx)[a b]/x)"; } - + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_19_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_19_matcher::to_string() -> std::string{return R"(/(?xx)[a b]/x)"; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_20_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_20_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2379,10 +2216,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_20_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_20_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2390,19 +2228,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_20_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_20_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_20_matcher::to_string() -> std::string{return R"(/(?-x:[a b])/xx)"; } + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_20_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_20_matcher::to_string() -> std::string{return R"(/(?-x:[a b])/xx)"; } - - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_21_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_21_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2417,11 +2255,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_21_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_21_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2435,11 +2274,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_21_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_21_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2453,10 +2293,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_21_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_21_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2464,19 +2305,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_21_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_21_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_21_matcher::to_string() -> std::string{return R"(/\N{1}/x)"; } - + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_21_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_21_matcher::to_string() -> std::string{return R"(/\N{1}/x)"; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_22_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_22_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2491,11 +2332,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_22_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_22_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2509,11 +2351,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_22_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_22_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2527,10 +2370,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_22_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_22_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2538,19 +2382,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_22_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_22_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_22_matcher::to_string() -> std::string{return R"(/\N{1}/x)"; } + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_22_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_22_matcher::to_string() -> std::string{return R"(/\N{1}/x)"; } - - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_23_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_23_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2565,11 +2409,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_23_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_23_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2583,11 +2428,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_23_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_23_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2601,10 +2447,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_23_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_23_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2612,19 +2459,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_23_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_23_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_23_matcher::to_string() -> std::string{return R"(/\N{1}/x)"; } - + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_23_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_23_matcher::to_string() -> std::string{return R"(/\N{1}/x)"; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_24_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_24_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2639,11 +2486,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_24_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_24_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2657,11 +2505,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_24_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_24_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2675,10 +2524,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_24_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_24_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2686,19 +2536,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_24_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_24_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_24_matcher::to_string() -> std::string{return R"(/\N{3,4}/x)"; } + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_24_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_24_matcher::to_string() -> std::string{return R"(/\N{3,4}/x)"; } - - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_25_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_25_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2713,11 +2563,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_25_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_25_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2731,11 +2582,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_25_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_25_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2749,10 +2601,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_25_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_25_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2760,19 +2613,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_25_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_25_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_25_matcher::to_string() -> std::string{return R"(/\N{3,4}/x)"; } - + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_25_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_25_matcher::to_string() -> std::string{return R"(/\N{3,4}/x)"; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_26_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_26_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2787,11 +2640,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_26_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_26_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2805,11 +2659,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_26_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_26_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2823,10 +2678,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_26_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_26_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2834,19 +2690,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_26_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_26_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_26_matcher::to_string() -> std::string{return R"(/\N{3,4}/x)"; } + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_26_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_26_matcher::to_string() -> std::string{return R"(/\N{3,4}/x)"; } - - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_27_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_27_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2889,10 +2745,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_27_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_27_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2900,19 +2757,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_27_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_27_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_27_matcher::to_string() -> std::string{return R"(/a\Nc/x)"; } - + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_27_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_27_matcher::to_string() -> std::string{return R"(/a\Nc/x)"; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_28_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_28_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2927,11 +2784,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_28_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_28_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2959,11 +2817,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_28_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_28_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2991,10 +2850,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_28_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_28_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3002,19 +2862,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_28_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_28_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_28_matcher::to_string() -> std::string{return R"(/a\N*c/x)"; } + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_28_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_28_matcher::to_string() -> std::string{return R"(/a\N*c/x)"; } - - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_29_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_29_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3029,11 +2889,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_29_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_29_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3061,11 +2922,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_29_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_29_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3093,10 +2955,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_29_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_29_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3104,19 +2967,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_29_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_29_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_29_matcher::to_string() -> std::string{return R"(/a\N*c/x)"; } - + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_29_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_29_matcher::to_string() -> std::string{return R"(/a\N*c/x)"; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_30_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_30_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3131,10 +2994,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_30_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_30_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3142,19 +3006,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_30_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_30_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_30_matcher::to_string() -> std::string{return R"(/[#]/)"; } + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_30_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_30_matcher::to_string() -> std::string{return R"(/[#]/)"; } - - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_31_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_31_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3183,10 +3047,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_31_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_31_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3194,19 +3059,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_31_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_31_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_31_matcher::to_string() -> std::string{return R"(/[#]b/)"; } - + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_31_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_31_matcher::to_string() -> std::string{return R"(/[#]b/)"; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_32_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_32_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3221,10 +3086,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_32_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_32_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3232,19 +3098,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_32_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_32_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_32_matcher::to_string() -> std::string{return R"(/[#]/x)"; } + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_32_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_32_matcher::to_string() -> std::string{return R"(/[#]/x)"; } - - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_33_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_33_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3273,10 +3139,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_33_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_33_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3284,15 +3151,16 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_33_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_33_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_33_matcher::to_string() -> std::string{return R"(/[#]b/x)"; } + template [[nodiscard]] constexpr auto test_tests_16_perl_syntax_modifier::regex_33_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_16_perl_syntax_modifier::regex_33_matcher::to_string() -> std::string{return R"(/[#]b/x)"; } -#line 237 "pure2-regex_16_perl_syntax_modifier.cpp2" +#line 238 "pure2-regex_16_perl_syntax_modifier.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_16_perl_syntax_modifier()); } diff --git a/regression-tests/test-results/pure2-regex_17_comments.cpp b/regression-tests/test-results/pure2-regex_17_comments.cpp index 94327da044..86b981d5b4 100644 --- a/regression-tests/test-results/pure2-regex_17_comments.cpp +++ b/regression-tests/test-results/pure2-regex_17_comments.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_17_comments.cpp2" -#line 165 "pure2-regex_17_comments.cpp2" +#line 166 "pure2-regex_17_comments.cpp2" class test_tests_17_comments; @@ -18,47 +18,41 @@ class test_tests_17_comments; #line 1 "pure2-regex_17_comments.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_17_comments.cpp2" +#line 113 "pure2-regex_17_comments.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_17_comments.cpp2" +#line 125 "pure2-regex_17_comments.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_17_comments.cpp2" +#line 166 "pure2-regex_17_comments.cpp2" class test_tests_17_comments { -#line 169 "pure2-regex_17_comments.cpp2" +#line 170 "pure2-regex_17_comments.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -66,35 +60,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -102,25 +90,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_02 {}; public: class regex_03_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_03_matcher() = default; public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -128,13 +110,13 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_03 {}; + public: cpp2::regex::regular_expression> regex_03 {}; public: test_tests_17_comments() = default; public: test_tests_17_comments(test_tests_17_comments const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_17_comments const&) -> void = delete; -#line 176 "pure2-regex_17_comments.cpp2" +#line 177 "pure2-regex_17_comments.cpp2" }; auto main() -> int; @@ -238,6 +220,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -253,7 +236,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_17_comments.cpp2" +#line 113 "pure2-regex_17_comments.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -266,7 +249,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_17_comments.cpp2" +#line 125 "pure2-regex_17_comments.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -307,7 +290,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 169 "pure2-regex_17_comments.cpp2" +#line 170 "pure2-regex_17_comments.cpp2" auto test_tests_17_comments::run() const& -> void{ std::cout << "Running tests_17_comments:" << std::endl; test(regex_01, "01", R"(^a(?#xxx){3}c)", "aaac", "y", R"($&)", "aaac"); @@ -319,8 +302,7 @@ template auto test(M const& regex, cpp2::impl::in id, c - - template [[nodiscard]] auto test_tests_17_comments::regex_01_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_17_comments::regex_01_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -348,11 +330,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_17_comments::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_17_comments::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -367,11 +350,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_17_comments::regex_01_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_17_comments::regex_01_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -399,10 +383,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_17_comments::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_17_comments::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -410,19 +395,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_17_comments::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_17_comments::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_17_comments::regex_01_matcher::to_string() -> std::string{return R"(^a(?#xxx){3}c)"; } + template [[nodiscard]] constexpr auto test_tests_17_comments::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_17_comments::regex_01_matcher::to_string() -> std::string{return R"(^a(?#xxx){3}c)"; } - - template [[nodiscard]] auto test_tests_17_comments::regex_02_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_17_comments::regex_02_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -450,11 +435,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_17_comments::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_17_comments::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -469,11 +455,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_17_comments::regex_02_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_17_comments::regex_02_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -501,10 +488,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_17_comments::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_17_comments::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -512,19 +500,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_17_comments::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_17_comments::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_17_comments::regex_02_matcher::to_string() -> std::string{return R"('^a(?#xxx)(?#yyy){3}c'x)"; } - + template [[nodiscard]] constexpr auto test_tests_17_comments::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_17_comments::regex_02_matcher::to_string() -> std::string{return R"('^a(?#xxx)(?#yyy){3}c'x)"; } - template [[nodiscard]] auto test_tests_17_comments::regex_03_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_17_comments::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -552,10 +540,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_17_comments::regex_03_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_17_comments::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -563,15 +552,16 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_17_comments::regex_03_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_17_comments::regex_03_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_17_comments::regex_03_matcher::to_string() -> std::string{return R"('foo'x)"; } + template [[nodiscard]] constexpr auto test_tests_17_comments::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_17_comments::regex_03_matcher::to_string() -> std::string{return R"('foo'x)"; } -#line 177 "pure2-regex_17_comments.cpp2" +#line 178 "pure2-regex_17_comments.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_17_comments()); } diff --git a/regression-tests/test-results/pure2-regex_18_branch_reset.cpp b/regression-tests/test-results/pure2-regex_18_branch_reset.cpp index d3c7033ce9..829d5278e1 100644 --- a/regression-tests/test-results/pure2-regex_18_branch_reset.cpp +++ b/regression-tests/test-results/pure2-regex_18_branch_reset.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_18_branch_reset.cpp2" -#line 165 "pure2-regex_18_branch_reset.cpp2" +#line 166 "pure2-regex_18_branch_reset.cpp2" class test_tests_18_branch_reset; @@ -18,37 +18,31 @@ class test_tests_18_branch_reset; #line 1 "pure2-regex_18_branch_reset.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_18_branch_reset.cpp2" +#line 113 "pure2-regex_18_branch_reset.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_18_branch_reset.cpp2" +#line 125 "pure2-regex_18_branch_reset.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_18_branch_reset.cpp2" +#line 166 "pure2-regex_18_branch_reset.cpp2" class test_tests_18_branch_reset { -#line 181 "pure2-regex_18_branch_reset.cpp2" +#line 182 "pure2-regex_18_branch_reset.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -56,11 +50,10 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -70,7 +63,7 @@ public: class func_1 { }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -80,7 +73,7 @@ public: class func_1 { }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -90,26 +83,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -117,11 +105,10 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_02 {}; public: class regex_03_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -131,7 +118,7 @@ public: class func_1 { }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -141,7 +128,7 @@ public: class func_1 { }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -151,26 +138,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_03_matcher() = default; public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -178,11 +160,10 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_03 {}; public: class regex_04_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -192,7 +173,7 @@ public: class func_1 { }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -202,7 +183,7 @@ public: class func_1 { }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -212,26 +193,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_04_matcher() = default; public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -239,11 +215,10 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_04 {}; public: class regex_05_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -253,7 +228,7 @@ public: class func_2 { }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -263,12 +238,12 @@ public: class func_2 { }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -278,7 +253,7 @@ public: class func_2 { }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -288,7 +263,7 @@ public: class func_2 { }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -298,12 +273,12 @@ public: class func_2 { }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -313,26 +288,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_9 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_05_matcher() = default; public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -340,11 +310,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_05 {}; public: class regex_06_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -354,7 +323,7 @@ public: class func_2 { }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -364,12 +333,12 @@ public: class func_2 { }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -379,7 +348,7 @@ public: class func_2 { }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -389,7 +358,7 @@ public: class func_2 { }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -399,12 +368,12 @@ public: class func_2 { }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -414,26 +383,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_9 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_06_matcher() = default; public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -441,11 +405,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_06 {}; public: class regex_07_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_06 {}; public: template class regex_07_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -455,7 +418,7 @@ public: class func_2 { }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -465,12 +428,12 @@ public: class func_2 { }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -480,7 +443,7 @@ public: class func_2 { }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -490,7 +453,7 @@ public: class func_2 { }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -500,12 +463,12 @@ public: class func_2 { }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -515,26 +478,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_9 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_07_matcher() = default; public: regex_07_matcher(regex_07_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -542,11 +500,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_07 {}; public: class regex_08_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_07 {}; public: template class regex_08_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -556,7 +513,7 @@ public: class func_2 { }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -566,12 +523,12 @@ public: class func_2 { }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -581,7 +538,7 @@ public: class func_2 { }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -591,7 +548,7 @@ public: class func_2 { }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -601,12 +558,12 @@ public: class func_2 { }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -616,26 +573,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_9 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_08_matcher() = default; public: regex_08_matcher(regex_08_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -643,11 +595,10 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_08 {}; public: class regex_09_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_08 {}; public: template class regex_09_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -657,7 +608,7 @@ public: class func_1 { }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -667,26 +618,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_09_matcher() = default; public: regex_09_matcher(regex_09_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -694,11 +640,10 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_09 {}; public: class regex_10_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_09 {}; public: template class regex_10_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -708,7 +653,7 @@ public: class func_1 { }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -718,26 +663,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_10_matcher() = default; public: regex_10_matcher(regex_10_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -745,25 +685,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_10 {}; public: class regex_11_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_10 {}; public: template class regex_11_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_11_matcher() = default; public: regex_11_matcher(regex_11_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -771,11 +705,10 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_11 {}; public: class regex_12_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_11 {}; public: template class regex_12_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -785,7 +718,7 @@ public: class func_1 { }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -795,26 +728,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_12_matcher() = default; public: regex_12_matcher(regex_12_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -822,11 +750,10 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_12 {}; public: class regex_13_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_12 {}; public: template class regex_13_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -836,7 +763,7 @@ public: class func_1 { }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -846,26 +773,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_13_matcher() = default; public: regex_13_matcher(regex_13_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -873,25 +795,19 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_13 {}; public: class regex_14_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_13 {}; public: template class regex_14_matcher { + public: template using context = cpp2::regex::match_context; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_14_matcher() = default; public: regex_14_matcher(regex_14_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -899,11 +815,10 @@ public: class func_0 { }; - public: cpp2::regex::regular_expression regex_14 {}; public: class regex_15_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_14 {}; public: template class regex_15_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -913,7 +828,7 @@ public: class func_1 { }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -923,26 +838,21 @@ public: class func_1 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_15_matcher() = default; public: regex_15_matcher(regex_15_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -950,13 +860,13 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_15 {}; + public: cpp2::regex::regular_expression> regex_15 {}; public: test_tests_18_branch_reset() = default; public: test_tests_18_branch_reset(test_tests_18_branch_reset const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_18_branch_reset const&) -> void = delete; -#line 200 "pure2-regex_18_branch_reset.cpp2" +#line 201 "pure2-regex_18_branch_reset.cpp2" }; auto main() -> int; @@ -1060,6 +970,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -1075,7 +986,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_18_branch_reset.cpp2" +#line 113 "pure2-regex_18_branch_reset.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -1088,7 +999,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_18_branch_reset.cpp2" +#line 125 "pure2-regex_18_branch_reset.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -1129,7 +1040,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 181 "pure2-regex_18_branch_reset.cpp2" +#line 182 "pure2-regex_18_branch_reset.cpp2" auto test_tests_18_branch_reset::run() const& -> void{ std::cout << "Running tests_18_branch_reset:" << std::endl; test(regex_01, "01", R"((?|(a)))", "a", "y", R"($1-$+)", "a-a"); @@ -1153,8 +1064,7 @@ template auto test(M const& regex, cpp2::impl::in id, c - - template [[nodiscard]] auto test_tests_18_branch_reset::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1195,10 +1105,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1206,19 +1117,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_18_branch_reset::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_18_branch_reset::regex_01_matcher::to_string() -> std::string{return R"((?|(a)))"; } + template [[nodiscard]] constexpr auto test_tests_18_branch_reset::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_18_branch_reset::regex_01_matcher::to_string() -> std::string{return R"((?|(a)))"; } - - template [[nodiscard]] auto test_tests_18_branch_reset::regex_02_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_02_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1274,16 +1185,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_02_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_02_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_02_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_02_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1367,17 +1279,18 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_02_matcher::wrap::reset_1::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_02_matcher::reset_1::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); ctx.set_group_invalid(2); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_02_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_02_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1447,17 +1360,18 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_02_matcher::wrap::reset_2::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_02_matcher::reset_2::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); ctx.set_group_invalid(2); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1471,11 +1385,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_02_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_02_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1503,10 +1418,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1514,19 +1430,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_18_branch_reset::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_18_branch_reset::regex_02_matcher::to_string() -> std::string{return R"((?|a(.)b|d(.(o).)d|i(.)(.)j)(.))"; } - + template [[nodiscard]] constexpr auto test_tests_18_branch_reset::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_18_branch_reset::regex_02_matcher::to_string() -> std::string{return R"((?|a(.)b|d(.(o).)d|i(.)(.)j)(.))"; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_03_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_03_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1582,16 +1498,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_03_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_03_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_03_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_03_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1675,17 +1592,18 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_03_matcher::wrap::reset_1::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_03_matcher::reset_1::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); ctx.set_group_invalid(2); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_03_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_03_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1755,17 +1673,18 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_03_matcher::wrap::reset_2::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_03_matcher::reset_2::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); ctx.set_group_invalid(2); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_03_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1779,11 +1698,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_03_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_03_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1811,10 +1731,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_03_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -1822,19 +1743,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_03_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_18_branch_reset::regex_03_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_18_branch_reset::regex_03_matcher::to_string() -> std::string{return R"((?|a(.)b|d(.(o).)d|i(.)(.)j)(.))"; } + template [[nodiscard]] constexpr auto test_tests_18_branch_reset::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_18_branch_reset::regex_03_matcher::to_string() -> std::string{return R"((?|a(.)b|d(.(o).)d|i(.)(.)j)(.))"; } - - template [[nodiscard]] auto test_tests_18_branch_reset::regex_04_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_04_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1890,16 +1811,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_04_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_04_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_04_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_04_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -1983,17 +1905,18 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_04_matcher::wrap::reset_1::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_04_matcher::reset_1::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); ctx.set_group_invalid(2); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_04_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_04_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2063,17 +1986,18 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_04_matcher::wrap::reset_2::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_04_matcher::reset_2::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); ctx.set_group_invalid(2); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_04_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2087,11 +2011,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_04_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_04_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2119,10 +2044,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_04_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2130,19 +2056,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_04_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_18_branch_reset::regex_04_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_18_branch_reset::regex_04_matcher::to_string() -> std::string{return R"((?|a(.)b|d(.(o).)d|i(.)(.)j)(.))"; } - + template [[nodiscard]] constexpr auto test_tests_18_branch_reset::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_18_branch_reset::regex_04_matcher::to_string() -> std::string{return R"((?|a(.)b|d(.(o).)d|i(.)(.)j)(.))"; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2183,16 +2109,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_05_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_05_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2233,16 +2160,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_05_matcher::wrap::reset_1::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_05_matcher::reset_1::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2256,11 +2184,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2274,16 +2203,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_05_matcher::wrap::reset_2::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_05_matcher::reset_2::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2324,16 +2254,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_05_matcher::wrap::reset_3::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_05_matcher::reset_3::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2374,16 +2305,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_05_matcher::wrap::reset_4::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_05_matcher::reset_4::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2397,11 +2329,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2415,16 +2348,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_05_matcher::wrap::reset_5::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_05_matcher::reset_5::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2438,11 +2372,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::wrap::func_9::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::func_9::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2456,10 +2391,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2467,19 +2403,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::to_string() -> std::string{return R"((?|(?|(a)|(b))|(?|(c)|(d))))"; } + template [[nodiscard]] constexpr auto test_tests_18_branch_reset::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_18_branch_reset::regex_05_matcher::to_string() -> std::string{return R"((?|(?|(a)|(b))|(?|(c)|(d))))"; } - - template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2520,16 +2456,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_06_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_06_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2570,16 +2507,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_06_matcher::wrap::reset_1::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_06_matcher::reset_1::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2593,11 +2531,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2611,16 +2550,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_06_matcher::wrap::reset_2::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_06_matcher::reset_2::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2661,16 +2601,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_06_matcher::wrap::reset_3::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_06_matcher::reset_3::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2711,16 +2652,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_06_matcher::wrap::reset_4::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_06_matcher::reset_4::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2734,11 +2676,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2752,16 +2695,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_06_matcher::wrap::reset_5::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_06_matcher::reset_5::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2775,11 +2719,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::wrap::func_9::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::func_9::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2793,10 +2738,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2804,19 +2750,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::to_string() -> std::string{return R"((?|(?|(a)|(b))|(?|(c)|(d))))"; } - + template [[nodiscard]] constexpr auto test_tests_18_branch_reset::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_18_branch_reset::regex_06_matcher::to_string() -> std::string{return R"((?|(?|(a)|(b))|(?|(c)|(d))))"; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2857,16 +2803,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_07_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_07_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2907,16 +2854,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_07_matcher::wrap::reset_1::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_07_matcher::reset_1::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2930,11 +2878,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2948,16 +2897,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_07_matcher::wrap::reset_2::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_07_matcher::reset_2::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2998,16 +2948,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_07_matcher::wrap::reset_3::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_07_matcher::reset_3::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3048,16 +2999,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_07_matcher::wrap::reset_4::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_07_matcher::reset_4::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3071,11 +3023,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3089,16 +3042,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_07_matcher::wrap::reset_5::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_07_matcher::reset_5::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3112,11 +3066,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::wrap::func_9::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::func_9::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3130,10 +3085,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3141,19 +3097,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::to_string() -> std::string{return R"((?|(?|(a)|(b))|(?|(c)|(d))))"; } + template [[nodiscard]] constexpr auto test_tests_18_branch_reset::regex_07_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_18_branch_reset::regex_07_matcher::to_string() -> std::string{return R"((?|(?|(a)|(b))|(?|(c)|(d))))"; } - - template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3194,16 +3150,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_08_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_08_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3244,16 +3201,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_08_matcher::wrap::reset_1::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_08_matcher::reset_1::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3267,11 +3225,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3285,16 +3244,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_08_matcher::wrap::reset_2::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_08_matcher::reset_2::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3335,16 +3295,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_08_matcher::wrap::reset_3::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_08_matcher::reset_3::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3385,16 +3346,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_08_matcher::wrap::reset_4::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_08_matcher::reset_4::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3408,11 +3370,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3426,16 +3389,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_08_matcher::wrap::reset_5::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_08_matcher::reset_5::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3449,11 +3413,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::wrap::func_9::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::func_9::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3467,10 +3432,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3478,19 +3444,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::to_string() -> std::string{return R"((?|(?|(a)|(b))|(?|(c)|(d))))"; } - + template [[nodiscard]] constexpr auto test_tests_18_branch_reset::regex_08_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_18_branch_reset::regex_08_matcher::to_string() -> std::string{return R"((?|(?|(a)|(b))|(?|(c)|(d))))"; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_09_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_09_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3546,17 +3512,18 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_09_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_09_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(2); ctx.set_group_invalid(3); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_09_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_09_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3598,16 +3565,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_09_matcher::wrap::reset_1::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_09_matcher::reset_1::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(2); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_09_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_09_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3635,11 +3603,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_09_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_09_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3667,10 +3636,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_09_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_09_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3678,19 +3648,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_09_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_18_branch_reset::regex_09_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_18_branch_reset::regex_09_matcher::to_string() -> std::string{return R"((.)(?|(.)(.)x|(.)d)(.))"; } + template [[nodiscard]] constexpr auto test_tests_18_branch_reset::regex_09_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_18_branch_reset::regex_09_matcher::to_string() -> std::string{return R"((.)(?|(.)(.)x|(.)d)(.))"; } - - template [[nodiscard]] auto test_tests_18_branch_reset::regex_10_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_10_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3746,17 +3716,18 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_10_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_10_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(2); ctx.set_group_invalid(3); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_10_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_10_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3798,16 +3769,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_10_matcher::wrap::reset_1::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_10_matcher::reset_1::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(2); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_10_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_10_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3835,11 +3807,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_10_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_10_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3867,10 +3840,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_10_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_10_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3878,19 +3852,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_10_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_18_branch_reset::regex_10_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_18_branch_reset::regex_10_matcher::to_string() -> std::string{return R"((\N)(?|(\N)(\N)x|(\N)d)(\N))"; } - + template [[nodiscard]] constexpr auto test_tests_18_branch_reset::regex_10_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_18_branch_reset::regex_10_matcher::to_string() -> std::string{return R"((\N)(?|(\N)(\N)x|(\N)d)(\N))"; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_11_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_11_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3931,10 +3905,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_11_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_11_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3942,18 +3917,18 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_11_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_18_branch_reset::regex_11_matcher::get_named_group_index(auto const& name) -> int{ if (name == "foo") {return 1; }else {return -1; } } - [[nodiscard]] auto test_tests_18_branch_reset::regex_11_matcher::to_string() -> std::string{return R"((?|(?x)))"; } + template [[nodiscard]] constexpr auto test_tests_18_branch_reset::regex_11_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_18_branch_reset::regex_11_matcher::to_string() -> std::string{return R"((?|(?x)))"; } - - template [[nodiscard]] auto test_tests_18_branch_reset::regex_12_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_12_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3994,16 +3969,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_12_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_12_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_12_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_12_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4044,16 +4020,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_18_branch_reset::regex_12_matcher::wrap::reset_1::operator()(auto& ctx) const& -> void{ + template auto test_tests_18_branch_reset::regex_12_matcher::reset_1::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_12_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_12_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4067,11 +4044,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_12_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_12_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4085,10 +4063,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_12_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_18_branch_reset::regex_12_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4096,20 +4075,20 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_18_branch_reset::regex_12_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_18_branch_reset::regex_12_matcher::get_named_group_index(auto const& name) -> int{ if (name == "bar") {return 1; }else {if (name == "foo") {return 1; }else {return -1; } #line 1 "pure2-regex_18_branch_reset.cpp2" } } -[[nodiscard]] auto test_tests_18_branch_reset::regex_12_matcher::to_string() -> std::string{return R"((?|(?x)|(?y)))"; } - +template [[nodiscard]] constexpr auto test_tests_18_branch_reset::regex_12_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_18_branch_reset::regex_12_matcher::to_string() -> std::string{return R"((?|(?x)|(?y)))"; } -template [[nodiscard]] auto test_tests_18_branch_reset::regex_13_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ +template template [[nodiscard]] auto test_tests_18_branch_reset::regex_13_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4150,16 +4129,17 @@ r = other(r.pos, ctx); else { r.pos = ctx.end; } +static_cast(CPP2_FORWARD(ctx)); return r; } -template auto test_tests_18_branch_reset::regex_13_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ +template auto test_tests_18_branch_reset::regex_13_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } -template [[nodiscard]] auto test_tests_18_branch_reset::regex_13_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ +template template [[nodiscard]] auto test_tests_18_branch_reset::regex_13_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4200,16 +4180,17 @@ r = other(r.pos, ctx); else { r.pos = ctx.end; } +static_cast(CPP2_FORWARD(ctx)); return r; } -template auto test_tests_18_branch_reset::regex_13_matcher::wrap::reset_1::operator()(auto& ctx) const& -> void{ +template auto test_tests_18_branch_reset::regex_13_matcher::reset_1::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } -template [[nodiscard]] auto test_tests_18_branch_reset::regex_13_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ +template template [[nodiscard]] auto test_tests_18_branch_reset::regex_13_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4223,11 +4204,12 @@ r = cpp2::regex::alternative_token_matcher::match(r.pos, ctx, other, func_ else { r.pos = ctx.end; } +static_cast(CPP2_FORWARD(ctx)); return r; } -template [[nodiscard]] auto test_tests_18_branch_reset::regex_13_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ +template template [[nodiscard]] auto test_tests_18_branch_reset::regex_13_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4241,10 +4223,11 @@ r = other(r.pos, ctx); else { r.pos = ctx.end; } +static_cast(CPP2_FORWARD(ctx)); return r; } -template [[nodiscard]] auto test_tests_18_branch_reset::regex_13_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ +template template [[nodiscard]] auto test_tests_18_branch_reset::regex_13_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4252,18 +4235,18 @@ if (r.matched) {ctx.set_group_end(0, r.pos);} return r; } -template [[nodiscard]] auto test_tests_18_branch_reset::regex_13_matcher::wrap::get_named_group_index(auto const& name) -> int{ +template [[nodiscard]] auto test_tests_18_branch_reset::regex_13_matcher::get_named_group_index(auto const& name) -> int{ if (name == "bar") {return 1; }else {if (name == "foo") {return 1; }else {return -1; }} } -[[nodiscard]] auto test_tests_18_branch_reset::regex_13_matcher::to_string() -> std::string{return R"((?|(?y)|(?x)))"; } +template [[nodiscard]] constexpr auto test_tests_18_branch_reset::regex_13_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_18_branch_reset::regex_13_matcher::to_string() -> std::string{return R"((?|(?y)|(?x)))"; } - -template [[nodiscard]] auto test_tests_18_branch_reset::regex_14_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ +template template [[nodiscard]] auto test_tests_18_branch_reset::regex_14_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4317,10 +4300,11 @@ r = other(r.pos, ctx); else { r.pos = ctx.end; } +static_cast(CPP2_FORWARD(ctx)); return r; } -template [[nodiscard]] auto test_tests_18_branch_reset::regex_14_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ +template template [[nodiscard]] auto test_tests_18_branch_reset::regex_14_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4328,18 +4312,18 @@ if (r.matched) {ctx.set_group_end(0, r.pos);} return r; } -template [[nodiscard]] auto test_tests_18_branch_reset::regex_14_matcher::wrap::get_named_group_index(auto const& name) -> int{ +template [[nodiscard]] auto test_tests_18_branch_reset::regex_14_matcher::get_named_group_index(auto const& name) -> int{ if (name == "bar") {return 1; }else {if (name == "foo") {return 2; }else {return -1; }} } -[[nodiscard]] auto test_tests_18_branch_reset::regex_14_matcher::to_string() -> std::string{return R"((?)(?|(?x)))"; } - +template [[nodiscard]] constexpr auto test_tests_18_branch_reset::regex_14_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_18_branch_reset::regex_14_matcher::to_string() -> std::string{return R"((?)(?|(?x)))"; } -template [[nodiscard]] auto test_tests_18_branch_reset::regex_15_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ +template template [[nodiscard]] auto test_tests_18_branch_reset::regex_15_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4380,16 +4364,17 @@ r = other(r.pos, ctx); else { r.pos = ctx.end; } +static_cast(CPP2_FORWARD(ctx)); return r; } -template auto test_tests_18_branch_reset::regex_15_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ +template auto test_tests_18_branch_reset::regex_15_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } -template [[nodiscard]] auto test_tests_18_branch_reset::regex_15_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ +template template [[nodiscard]] auto test_tests_18_branch_reset::regex_15_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6770,11 +6755,12 @@ r = other(r.pos, ctx); else { r.pos = ctx.end; } +static_cast(CPP2_FORWARD(ctx)); return r; } -template auto test_tests_18_branch_reset::regex_15_matcher::wrap::reset_1::operator()(auto& ctx) const& -> void{ +template auto test_tests_18_branch_reset::regex_15_matcher::reset_1::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); ctx.set_group_invalid(2); ctx.set_group_invalid(3); @@ -6959,7 +6945,7 @@ ctx.set_group_invalid(181); } -template [[nodiscard]] auto test_tests_18_branch_reset::regex_15_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ +template template [[nodiscard]] auto test_tests_18_branch_reset::regex_15_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6973,11 +6959,12 @@ r = cpp2::regex::alternative_token_matcher::match(r.pos, ctx, other, func_ else { r.pos = ctx.end; } +static_cast(CPP2_FORWARD(ctx)); return r; } -template [[nodiscard]] auto test_tests_18_branch_reset::regex_15_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ +template template [[nodiscard]] auto test_tests_18_branch_reset::regex_15_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6991,10 +6978,11 @@ r = other(r.pos, ctx); else { r.pos = ctx.end; } +static_cast(CPP2_FORWARD(ctx)); return r; } -template [[nodiscard]] auto test_tests_18_branch_reset::regex_15_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ +template template [[nodiscard]] auto test_tests_18_branch_reset::regex_15_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7002,15 +6990,16 @@ if (r.matched) {ctx.set_group_end(0, r.pos);} return r; } -template [[nodiscard]] auto test_tests_18_branch_reset::regex_15_matcher::wrap::get_named_group_index(auto const& name) -> int{ +template [[nodiscard]] auto test_tests_18_branch_reset::regex_15_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } -[[nodiscard]] auto test_tests_18_branch_reset::regex_15_matcher::to_string() -> std::string{return R"((?|(b)|()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(a)))"; } +template [[nodiscard]] constexpr auto test_tests_18_branch_reset::regex_15_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_18_branch_reset::regex_15_matcher::to_string() -> std::string{return R"((?|(b)|()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(a)))"; } -#line 201 "pure2-regex_18_branch_reset.cpp2" +#line 202 "pure2-regex_18_branch_reset.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_18_branch_reset()); } diff --git a/regression-tests/test-results/pure2-regex_19_lookahead.cpp b/regression-tests/test-results/pure2-regex_19_lookahead.cpp index 8d007c9668..26955d7e27 100644 --- a/regression-tests/test-results/pure2-regex_19_lookahead.cpp +++ b/regression-tests/test-results/pure2-regex_19_lookahead.cpp @@ -9,7 +9,7 @@ #line 1 "pure2-regex_19_lookahead.cpp2" -#line 165 "pure2-regex_19_lookahead.cpp2" +#line 166 "pure2-regex_19_lookahead.cpp2" class test_tests_19_lookahead; @@ -18,42 +18,36 @@ class test_tests_19_lookahead; #line 1 "pure2-regex_19_lookahead.cpp2" [[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; -#line 112 "pure2-regex_19_lookahead.cpp2" +#line 113 "pure2-regex_19_lookahead.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string; -#line 124 "pure2-regex_19_lookahead.cpp2" +#line 125 "pure2-regex_19_lookahead.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void; -#line 165 "pure2-regex_19_lookahead.cpp2" +#line 166 "pure2-regex_19_lookahead.cpp2" class test_tests_19_lookahead { -#line 211 "pure2-regex_19_lookahead.cpp2" +#line 222 "pure2-regex_19_lookahead.cpp2" public: auto run() const& -> void; - public: class regex_01_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_01_matcher() = default; public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -61,30 +55,24 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_01 {}; public: class regex_02_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_02_matcher() = default; public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -92,30 +80,24 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_02 {}; public: class regex_03_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_03_matcher() = default; public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -123,45 +105,39 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_03 {}; public: class regex_04_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_04_matcher() = default; public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -169,21 +145,20 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_04 {}; public: class regex_05_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -193,12 +168,12 @@ public: class func_2 { }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -208,26 +183,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_05_matcher() = default; public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -235,40 +205,34 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_05 {}; public: class regex_06_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_06_matcher() = default; public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -276,40 +240,34 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_06 {}; public: class regex_07_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_06 {}; public: template class regex_07_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_07_matcher() = default; public: regex_07_matcher(regex_07_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -317,40 +275,34 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_07 {}; public: class regex_08_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_07 {}; public: template class regex_08_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_08_matcher() = default; public: regex_08_matcher(regex_08_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -358,40 +310,34 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_08 {}; public: class regex_09_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_08 {}; public: template class regex_09_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_09_matcher() = default; public: regex_09_matcher(regex_09_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -399,40 +345,34 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_09 {}; public: class regex_10_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_09 {}; public: template class regex_10_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_10_matcher() = default; public: regex_10_matcher(regex_10_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -440,40 +380,34 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_10 {}; public: class regex_11_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_10 {}; public: template class regex_11_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_11_matcher() = default; public: regex_11_matcher(regex_11_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -481,55 +415,49 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_11 {}; public: class regex_12_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_11 {}; public: template class regex_12_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_12_matcher() = default; public: regex_12_matcher(regex_12_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -537,55 +465,49 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_12 {}; public: class regex_13_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_12 {}; public: template class regex_13_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_13_matcher() = default; public: regex_13_matcher(regex_13_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -593,55 +515,49 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_13 {}; public: class regex_14_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_13 {}; public: template class regex_14_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_14_matcher() = default; public: regex_14_matcher(regex_14_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -649,55 +565,49 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_14 {}; public: class regex_15_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_14 {}; public: template class regex_15_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_15_matcher() = default; public: regex_15_matcher(regex_15_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -705,40 +615,34 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_15 {}; public: class regex_16_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_15 {}; public: template class regex_16_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_16_matcher() = default; public: regex_16_matcher(regex_16_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -746,40 +650,34 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_16 {}; public: class regex_17_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_16 {}; public: template class regex_17_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_17_matcher() = default; public: regex_17_matcher(regex_17_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -787,40 +685,34 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_17 {}; public: class regex_18_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_17 {}; public: template class regex_18_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_18_matcher() = default; public: regex_18_matcher(regex_18_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -828,40 +720,34 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_18 {}; public: class regex_19_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_18 {}; public: template class regex_19_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_19_matcher() = default; public: regex_19_matcher(regex_19_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -869,55 +755,49 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_19 {}; public: class regex_20_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_19 {}; public: template class regex_20_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_20_matcher() = default; public: regex_20_matcher(regex_20_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -925,55 +805,49 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_20 {}; public: class regex_21_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_20 {}; public: template class regex_21_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_21_matcher() = default; public: regex_21_matcher(regex_21_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -981,55 +855,49 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_21 {}; public: class regex_22_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_21 {}; public: template class regex_22_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_22_matcher() = default; public: regex_22_matcher(regex_22_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1037,55 +905,49 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_22 {}; public: class regex_23_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_22 {}; public: template class regex_23_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_23_matcher() = default; public: regex_23_matcher(regex_23_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1093,40 +955,34 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_23 {}; public: class regex_24_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_23 {}; public: template class regex_24_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_24_matcher() = default; public: regex_24_matcher(regex_24_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1134,40 +990,34 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_24 {}; public: class regex_25_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_24 {}; public: template class regex_25_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_25_matcher() = default; public: regex_25_matcher(regex_25_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1175,36 +1025,35 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_25 {}; public: class regex_26_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_25 {}; public: template class regex_26_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1214,36 +1063,31 @@ public: class func_1 { }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_9 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_26_matcher() = default; public: regex_26_matcher(regex_26_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1251,35 +1095,29 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_26 {}; public: class regex_27_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_26 {}; public: template class regex_27_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_27_matcher() = default; public: regex_27_matcher(regex_27_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1287,35 +1125,29 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_27 {}; public: class regex_28_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_27 {}; public: template class regex_28_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_28_matcher() = default; public: regex_28_matcher(regex_28_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1323,26 +1155,265 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_28 {}; public: class regex_37_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_28 {}; public: template class regex_29_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_29_matcher() = default; + public: regex_29_matcher(regex_29_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_29_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_29 {}; public: template class regex_30_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_30_matcher() = default; + public: regex_30_matcher(regex_30_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_30_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_30 {}; public: template class regex_31_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_31_matcher() = default; + public: regex_31_matcher(regex_31_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_31_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_31 {}; public: template class regex_32_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_32_matcher() = default; + public: regex_32_matcher(regex_32_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_32_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_32 {}; public: template class regex_33_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_33_matcher() = default; + public: regex_33_matcher(regex_33_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_33_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_33 {}; public: template class regex_34_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_34_matcher() = default; + public: regex_34_matcher(regex_34_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_34_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_34 {}; public: template class regex_35_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_35_matcher() = default; + public: regex_35_matcher(regex_35_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_35_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_35 {}; public: template class regex_36_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_36_matcher() = default; + public: regex_36_matcher(regex_36_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_36_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_36 {}; public: template class regex_37_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1352,17 +1423,17 @@ public: class func_2 { }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1372,26 +1443,21 @@ public: class func_2 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_37_matcher() = default; public: regex_37_matcher(regex_37_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1399,40 +1465,34 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_37 {}; public: class regex_38_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_37 {}; public: template class regex_38_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_38_matcher() = default; public: regex_38_matcher(regex_38_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1440,30 +1500,24 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_38 {}; public: class regex_39_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_38 {}; public: template class regex_39_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_39_matcher() = default; public: regex_39_matcher(regex_39_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1471,40 +1525,34 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_39 {}; public: class regex_40_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_39 {}; public: template class regex_40_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_40_matcher() = default; public: regex_40_matcher(regex_40_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1512,36 +1560,35 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_40 {}; public: class regex_41_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_40 {}; public: template class regex_41_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1551,41 +1598,36 @@ public: class func_1 { }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_9 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_10 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_41_matcher() = default; public: regex_41_matcher(regex_41_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1593,36 +1635,35 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_41 {}; public: class regex_42_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_41 {}; public: template class regex_42_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1632,31 +1673,26 @@ public: class func_1 { }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_42_matcher() = default; public: regex_42_matcher(regex_42_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1664,41 +1700,40 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_42 {}; public: class regex_43_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_42 {}; public: template class regex_43_matcher { + public: template using context = cpp2::regex::match_context; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1708,26 +1743,21 @@ public: class func_3 { }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_43_matcher() = default; public: regex_43_matcher(regex_43_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1735,56 +1765,55 @@ public: class func_3 { }; - public: cpp2::regex::regular_expression regex_43 {}; public: class regex_44_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_43 {}; public: template class regex_44_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_9 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_10 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_11 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1794,31 +1823,26 @@ public: class func_1 { }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_12 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_44_matcher() = default; public: regex_44_matcher(regex_44_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1826,45 +1850,39 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_44 {}; public: class regex_45_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_44 {}; public: template class regex_45_matcher { + public: template using context = cpp2::regex::match_context; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_45_matcher() = default; public: regex_45_matcher(regex_45_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1872,31 +1890,30 @@ public: class func_4 { }; - public: cpp2::regex::regular_expression regex_45 {}; public: class regex_46_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_45 {}; public: template class regex_46_matcher { + public: template using context = cpp2::regex::match_context; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_6 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_5 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_7 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1906,22 +1923,22 @@ public: class func_2 { }; public: class func_4 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_11 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_10 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_12 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; @@ -1931,51 +1948,46 @@ public: class func_2 { }; public: class func_9 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_13 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_8 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_14 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_15 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_46_matcher() = default; public: regex_46_matcher(regex_46_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -1983,30 +1995,24 @@ public: class func_2 { }; - public: cpp2::regex::regular_expression regex_46 {}; public: class regex_47_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_46 {}; public: template class regex_47_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_47_matcher() = default; public: regex_47_matcher(regex_47_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2014,30 +2020,24 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_47 {}; public: class regex_48_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_47 {}; public: template class regex_48_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_48_matcher() = default; public: regex_48_matcher(regex_48_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2045,30 +2045,24 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_48 {}; public: class regex_49_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_48 {}; public: template class regex_49_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_49_matcher() = default; public: regex_49_matcher(regex_49_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2076,30 +2070,24 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_49 {}; public: class regex_50_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_49 {}; public: template class regex_50_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_50_matcher() = default; public: regex_50_matcher(regex_50_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2107,30 +2095,24 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_50 {}; public: class regex_51_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_50 {}; public: template class regex_51_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_51_matcher() = default; public: regex_51_matcher(regex_51_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2138,30 +2120,24 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_51 {}; public: class regex_52_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_51 {}; public: template class regex_52_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_52_matcher() = default; public: regex_52_matcher(regex_52_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2169,40 +2145,34 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_52 {}; public: class regex_53_matcher { - public: template class wrap { - public: using context = cpp2::regex::match_context; + public: cpp2::regex::regular_expression> regex_52 {}; public: template class regex_53_matcher { + public: template using context = cpp2::regex::match_context; public: class func_1 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_0 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_3 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; public: class func_2 { - public: [[nodiscard]] auto operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return; + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; }; - public: [[nodiscard]] static auto entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return; + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; - public: wrap() = default; - public: wrap(wrap const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(wrap const&) -> void = delete; - - }; - - public: [[nodiscard]] static auto to_string() -> std::string; + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; public: regex_53_matcher() = default; public: regex_53_matcher(regex_53_matcher const&) = delete; /* No 'that' constructor, suppress copy */ @@ -2210,13 +2180,53 @@ public: class func_1 { }; - public: cpp2::regex::regular_expression regex_53 {}; + public: cpp2::regex::regular_expression> regex_53 {}; public: template class regex_54_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_54_matcher() = default; + public: regex_54_matcher(regex_54_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_54_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_54 {}; public: template class regex_55_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_55_matcher() = default; + public: regex_55_matcher(regex_55_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_55_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_55 {}; public: test_tests_19_lookahead() = default; public: test_tests_19_lookahead(test_tests_19_lookahead const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(test_tests_19_lookahead const&) -> void = delete; -#line 260 "pure2-regex_19_lookahead.cpp2" +#line 281 "pure2-regex_19_lookahead.cpp2" }; auto main() -> int; @@ -2320,6 +2330,7 @@ auto main() -> int; } result += std::to_string(cpp2::move(pos)); } + ++next; } else { std::cerr << "Not implemented"; @@ -2335,7 +2346,7 @@ auto main() -> int; return result; } -#line 112 "pure2-regex_19_lookahead.cpp2" +#line 113 "pure2-regex_19_lookahead.cpp2" [[nodiscard]] auto sanitize(std::string str) -> std::string { str = cpp2::string_util::replace_all(str, "\a", "\\a"); @@ -2348,7 +2359,7 @@ auto main() -> int; return cpp2::move(str); } -#line 124 "pure2-regex_19_lookahead.cpp2" +#line 125 "pure2-regex_19_lookahead.cpp2" template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, cpp2::impl::in resultExpected) -> void{ @@ -2389,7 +2400,7 @@ template auto test(M const& regex, cpp2::impl::in id, c std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; } -#line 211 "pure2-regex_19_lookahead.cpp2" +#line 222 "pure2-regex_19_lookahead.cpp2" auto test_tests_19_lookahead::run() const& -> void{ std::cout << "Running tests_19_lookahead:" << std::endl; test(regex_01, "01", R"(a(?!b).)", "abad", "y", R"($&)", "ad"); @@ -2420,6 +2431,14 @@ template auto test(M const& regex, cpp2::impl::in id, c test(regex_26, "26", R"(^(a*?)(?!(aa|aaaa)*$)(?=a\z))", "aaaaaaaa", "y", R"($1)", "aaaaaaa"); test(regex_27, "27", R"(a(?!b(?!c))(..))", "abababc", "y", R"($1)", "bc"); test(regex_28, "28", R"(a(?!b(?=a))(..))", "abababc", "y", R"($1)", "bc"); + test(regex_29, "29", R"((?=foo))", "foo", "y", R"(@+)", "0"); + test(regex_30, "30", R"((?=foo))", "XfooY", "y", R"(@+)", "1"); + test(regex_31, "31", R"(.*(?=foo))", "XfooY", "y", R"(@+)", "1"); + test(regex_32, "32", R"((?=.*P)P)", "aP", "y", R"(@+)", "2"); + test(regex_33, "33", R"(X(?=foo)f)", "..XfooY..", "y", R"(@+)", "4"); + test(regex_34, "34", R"(X(?=foo))", "..XfooY..", "y", R"(@+)", "3"); + test(regex_35, "35", R"((?=XY*foo))", "Xfoo", "y", R"(@+)", "0"); + test(regex_36, "36", R"(^(?=XY*foo))", "Xfoo", "y", R"(@+)", "0"); test(regex_37, "37", R"(X(\w+)(?=\s)|X(\w+))", "Xab", "y", R"([$1-$2])", "[-ab]"); test(regex_38, "38", R"(^a*(?=b)b)", "ab", "y", R"($&)", "ab"); test(regex_39, "39", R"('(?!\A)x'm)", "a\nxb\n", "y", R"(-)", "-"); @@ -2437,14 +2456,15 @@ template auto test(M const& regex, cpp2::impl::in id, c test(regex_51, "51", R"(((?s)b.)c(?!\N))", "a\nb\nc\n", "y", R"($1:$&)", "b\n:b\nc"); test(regex_52, "52", R"('(b.)c(?!\N)'s)", "a\nb\nc\n", "y", R"($1:$&)", "b\n:b\nc"); test(regex_53, "53", R"(a*(?!))", "aaaab", "n", R"(-)", "-"); + test(regex_54, "54", R"((?)foo)", "bar>ABCfoo", "y", R"($&)", "foo"); + test(regex_55, "55", R"((?ABC)foo)", "bar>ABCfoo", "y", R"($&)", "ABCfoo"); std::cout << std::endl; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_01_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_01_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2472,11 +2492,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_01_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2506,10 +2527,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_01_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2517,19 +2539,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_01_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_01_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_01_matcher::to_string() -> std::string{return R"(a(?!b).)"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_01_matcher::to_string() -> std::string{return R"(a(?!b).)"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_02_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_02_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2543,11 +2565,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_02_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2576,10 +2599,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_02_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2587,19 +2611,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_02_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_02_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_02_matcher::to_string() -> std::string{return R"((?=)a)"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_02_matcher::to_string() -> std::string{return R"((?=)a)"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_03_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_03_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2627,11 +2651,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_03_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2661,10 +2686,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_03_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2672,19 +2698,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_03_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_03_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_03_matcher::to_string() -> std::string{return R"(a(?=d).)"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_03_matcher::to_string() -> std::string{return R"(a(?=d).)"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_04_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_04_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2712,11 +2738,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_04_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_04_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2744,11 +2771,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_04_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_04_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2762,11 +2790,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_04_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_04_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2780,11 +2809,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_04_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2814,10 +2844,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_04_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -2825,19 +2856,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_04_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_04_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_04_matcher::to_string() -> std::string{return R"(a(?=c|d).)"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_04_matcher::to_string() -> std::string{return R"(a(?=c|d).)"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2865,11 +2896,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2897,11 +2929,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2930,16 +2963,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_19_lookahead::regex_05_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_19_lookahead::regex_05_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2953,11 +2987,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2971,16 +3006,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_19_lookahead::regex_05_matcher::wrap::reset_1::operator()(auto& ctx) const& -> void{ + template auto test_tests_19_lookahead::regex_05_matcher::reset_1::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -2995,15 +3031,16 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -3014,10 +3051,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3025,19 +3063,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::to_string() -> std::string{return R"(^(?:b|a(?=(.)))*\1)"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_05_matcher::to_string() -> std::string{return R"(^(?:b|a(?=(.)))*\1)"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_06_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_06_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3065,11 +3103,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_06_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_06_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3084,11 +3123,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_06_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_06_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3114,17 +3154,18 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_06_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} ctx.set_group_start(2, r.pos); - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} std::array str_tmp_2 {"ab"}; if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),2)) { @@ -3161,10 +3202,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_06_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3172,19 +3214,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_06_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_06_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_06_matcher::to_string() -> std::string{return R"((?=(a+?))(\1ab))"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_06_matcher::to_string() -> std::string{return R"((?=(a+?))(\1ab))"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_07_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_07_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3212,11 +3254,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_07_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_07_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3231,11 +3274,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_07_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_07_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3261,17 +3305,18 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_07_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_07_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { if (!(cpp2::regex::line_start_token_matcher(r.pos, ctx))) {r.matched = false;break;} if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} std::array str_tmp_2 {"ab"}; if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),2)) { @@ -3296,10 +3341,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_07_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_07_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3307,19 +3353,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_07_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_07_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_07_matcher::to_string() -> std::string{return R"(^(?=(a+?))\1ab)"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_07_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_07_matcher::to_string() -> std::string{return R"(^(?=(a+?))\1ab)"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_08_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_08_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3347,11 +3393,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_08_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_08_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3366,11 +3413,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_08_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_08_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3396,17 +3444,18 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_08_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_08_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} ctx.set_group_start(2, r.pos); - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} std::array str_tmp_2 {"ab"}; if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),2)) { @@ -3443,10 +3492,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_08_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_08_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3454,19 +3504,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_08_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_08_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_08_matcher::to_string() -> std::string{return R"((?=(a+?))(\1ab))"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_08_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_08_matcher::to_string() -> std::string{return R"((?=(a+?))(\1ab))"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_09_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_09_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3494,11 +3544,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_09_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_09_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3513,11 +3564,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_09_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_09_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3543,17 +3595,18 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_09_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_09_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { if (!(cpp2::regex::line_start_token_matcher(r.pos, ctx))) {r.matched = false;break;} if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} std::array str_tmp_2 {"ab"}; if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),2)) { @@ -3578,10 +3631,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_09_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_09_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3589,19 +3643,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_09_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_09_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_09_matcher::to_string() -> std::string{return R"(^(?=(a+?))\1ab)"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_09_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_09_matcher::to_string() -> std::string{return R"(^(?=(a+?))\1ab)"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_10_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_10_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3616,11 +3670,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_10_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_10_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3635,11 +3690,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_10_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_10_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3667,11 +3723,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_10_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_10_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3698,10 +3755,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_10_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_10_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3709,19 +3767,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_10_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_10_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_10_matcher::to_string() -> std::string{return R"((.*)(?=c))"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_10_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_10_matcher::to_string() -> std::string{return R"((.*)(?=c))"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_11_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_11_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3736,11 +3794,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_11_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_11_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3755,11 +3814,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_11_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_11_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3787,11 +3847,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_11_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_11_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3832,10 +3893,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_11_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_11_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -3843,19 +3905,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_11_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_11_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_11_matcher::to_string() -> std::string{return R"((.*)(?=c)c)"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_11_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_11_matcher::to_string() -> std::string{return R"((.*)(?=c)c)"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3870,11 +3932,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3889,11 +3952,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3921,11 +3985,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3953,11 +4018,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3971,11 +4037,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -3989,11 +4056,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4020,10 +4088,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4031,19 +4100,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::to_string() -> std::string{return R"((.*)(?=b|c))"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_12_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_12_matcher::to_string() -> std::string{return R"((.*)(?=b|c))"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4058,11 +4127,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4077,11 +4147,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4109,11 +4180,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4141,11 +4213,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4159,11 +4232,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4177,11 +4251,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4222,10 +4297,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4233,19 +4309,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::to_string() -> std::string{return R"((.*)(?=b|c)c)"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_13_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_13_matcher::to_string() -> std::string{return R"((.*)(?=b|c)c)"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4260,11 +4336,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4279,11 +4356,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4311,11 +4389,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4343,11 +4422,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4361,11 +4441,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4379,11 +4460,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4410,10 +4492,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4421,19 +4504,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::to_string() -> std::string{return R"((.*)(?=c|b))"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_14_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_14_matcher::to_string() -> std::string{return R"((.*)(?=c|b))"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4448,11 +4531,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4467,11 +4551,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4499,11 +4584,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4531,11 +4617,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4549,11 +4636,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4567,11 +4655,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4612,10 +4701,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4623,19 +4713,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::to_string() -> std::string{return R"((.*)(?=c|b)c)"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_15_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_15_matcher::to_string() -> std::string{return R"((.*)(?=c|b)c)"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_16_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_16_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4650,11 +4740,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_16_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_16_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4669,11 +4760,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_16_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_16_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4688,11 +4780,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_16_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_16_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4719,10 +4812,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_16_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_16_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4730,19 +4824,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_16_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_16_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_16_matcher::to_string() -> std::string{return R"((.*)(?=[bc]))"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_16_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_16_matcher::to_string() -> std::string{return R"((.*)(?=[bc]))"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_17_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_17_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4757,11 +4851,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_17_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_17_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4776,11 +4871,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_17_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_17_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4795,11 +4891,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_17_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_17_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4840,10 +4937,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_17_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_17_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4851,19 +4949,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_17_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_17_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_17_matcher::to_string() -> std::string{return R"((.*)(?=[bc])c)"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_17_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_17_matcher::to_string() -> std::string{return R"((.*)(?=[bc])c)"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_18_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_18_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4878,11 +4976,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_18_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_18_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4897,11 +4996,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_18_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_18_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4929,11 +5029,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_18_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_18_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4960,10 +5061,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_18_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_18_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -4971,19 +5073,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_18_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_18_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_18_matcher::to_string() -> std::string{return R"((.*?)(?=c))"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_18_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_18_matcher::to_string() -> std::string{return R"((.*?)(?=c))"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_19_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_19_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -4998,11 +5100,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_19_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_19_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5017,11 +5120,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_19_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_19_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5049,11 +5153,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_19_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_19_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5094,10 +5199,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_19_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_19_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5105,19 +5211,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_19_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_19_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_19_matcher::to_string() -> std::string{return R"((.*?)(?=c)c)"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_19_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_19_matcher::to_string() -> std::string{return R"((.*?)(?=c)c)"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5132,11 +5238,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5151,11 +5258,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5183,11 +5291,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5215,11 +5324,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5233,11 +5343,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5251,11 +5362,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5282,10 +5394,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5293,19 +5406,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::to_string() -> std::string{return R"((.*?)(?=b|c))"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_20_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_20_matcher::to_string() -> std::string{return R"((.*?)(?=b|c))"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5320,11 +5433,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5339,11 +5453,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5371,11 +5486,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5403,11 +5519,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5421,11 +5538,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5439,11 +5557,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5484,10 +5603,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5495,19 +5615,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::to_string() -> std::string{return R"((.*?)(?=b|c)c)"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_21_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_21_matcher::to_string() -> std::string{return R"((.*?)(?=b|c)c)"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5522,11 +5642,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5541,11 +5662,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5573,11 +5695,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5605,11 +5728,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5623,11 +5747,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5641,11 +5766,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5672,10 +5798,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5683,19 +5810,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::to_string() -> std::string{return R"((.*?)(?=c|b))"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_22_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_22_matcher::to_string() -> std::string{return R"((.*?)(?=c|b))"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5710,11 +5837,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5729,11 +5857,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5761,11 +5890,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5793,11 +5923,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5811,11 +5942,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5829,11 +5961,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5874,10 +6007,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5885,19 +6019,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::to_string() -> std::string{return R"((.*?)(?=c|b)c)"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_23_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_23_matcher::to_string() -> std::string{return R"((.*?)(?=c|b)c)"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_24_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_24_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5912,11 +6046,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_24_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_24_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5931,11 +6066,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_24_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_24_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5950,11 +6086,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_24_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_24_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -5981,10 +6118,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_24_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_24_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -5992,19 +6130,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_24_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_24_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_24_matcher::to_string() -> std::string{return R"((.*?)(?=[bc]))"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_24_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_24_matcher::to_string() -> std::string{return R"((.*?)(?=[bc]))"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_25_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_25_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6019,11 +6157,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_25_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_25_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6038,11 +6177,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_25_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_25_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6057,11 +6197,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_25_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_25_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6102,10 +6243,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_25_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_25_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6113,19 +6255,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_25_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_25_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_25_matcher::to_string() -> std::string{return R"((.*?)(?=[bc])c)"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_25_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_25_matcher::to_string() -> std::string{return R"((.*?)(?=[bc])c)"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6153,11 +6295,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6173,11 +6316,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6205,11 +6349,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6237,11 +6382,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6256,11 +6402,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6286,16 +6433,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_19_lookahead::regex_26_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_19_lookahead::regex_26_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(2); } - template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6309,11 +6457,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6328,29 +6477,865 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::func_9::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_5 {"a"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_5, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + if (!(cpp2::regex::line_end_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_1_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_1 {cpp2::regex::make_on_return(cpp2::move(tmp_1_func))}; + static_cast(cpp2::move(tmp_1)); + if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_9()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_26_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::to_string() -> std::string{return R"(^(a*?)(?!(aa|aaaa)*$)(?=a\z))"; } + + + + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_27_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_2 {"c"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_27_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_2()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::wrap::func_9::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_27_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"a"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + ctx.set_group_start(1, r.pos); + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + ctx.set_group_end(1, r.pos); + + auto tmp_3_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_3 {cpp2::regex::make_on_return(cpp2::move(tmp_3_func))}; + static_cast(cpp2::move(tmp_3)); + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_27_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_19_lookahead::regex_27_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_27_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_27_matcher::to_string() -> std::string{return R"(a(?!b(?!c))(..))"; } + + + + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_28_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_2 {"a"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_28_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_2()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_28_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"a"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + ctx.set_group_start(1, r.pos); + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + ctx.set_group_end(1, r.pos); + + auto tmp_3_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_3 {cpp2::regex::make_on_return(cpp2::move(tmp_3_func))}; + static_cast(cpp2::move(tmp_3)); + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_28_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_19_lookahead::regex_28_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_28_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_28_matcher::to_string() -> std::string{return R"(a(?!b(?=a))(..))"; } + + + + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_29_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"foo"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_29_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_29_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_19_lookahead::regex_29_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_29_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_29_matcher::to_string() -> std::string{return R"((?=foo))"; } + + + + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_30_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"foo"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_30_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_30_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_19_lookahead::regex_30_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_30_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_30_matcher::to_string() -> std::string{return R"((?=foo))"; } + + + + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_31_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_31_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_2()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_31_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"foo"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_31_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_31_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_19_lookahead::regex_31_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_31_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_31_matcher::to_string() -> std::string{return R"(.*(?=foo))"; } + + + + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_32_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_32_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_2(), cpp2::regex::no_reset(), other, func_3()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_32_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"P"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_32_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_1 {"P"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_32_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_19_lookahead::regex_32_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_32_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_32_matcher::to_string() -> std::string{return R"((?=.*P)P)"; } + + + + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_33_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"foo"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_33_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"X"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} + + std::array str_tmp_2 {"f"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_33_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_19_lookahead::regex_33_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_33_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_33_matcher::to_string() -> std::string{return R"(X(?=foo)f)"; } + + + + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_34_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { - std::array str_tmp_5 {"a"}; - if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + std::array str_tmp_1 {"foo"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { r.matched = false; break; } { int i{0}; - for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { - if (CPP2_ASSERT_IN_BOUNDS(str_tmp_5, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} } } - if (r.matched) {r.pos += 1;} + if (r.matched) {r.pos += 3;} else {break;} - if (!(cpp2::regex::line_end_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -6361,28 +7346,30 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_34_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { - ctx.set_group_end(1, r.pos); - auto tmp_1_func { -[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ - if (!((*cpp2::impl::assert_not_null(_1)).matched)) { - (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + std::array str_tmp_0 {"X"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} } - }; - - auto tmp_1 {cpp2::regex::make_on_return(cpp2::move(tmp_1_func))}; - static_cast(cpp2::move(tmp_1)); - if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_3()))) {r.matched = false;break;} - if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_9()))) {r.matched = false;break;} +} + if (r.matched) {r.pos += 1;} + else {break;} + if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} } while ( false @@ -6393,10 +7380,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_34_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6404,24 +7392,24 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_34_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_26_matcher::to_string() -> std::string{return R"(^(a*?)(?!(aa|aaaa)*$)(?=a\z))"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_34_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_34_matcher::to_string() -> std::string{return R"(X(?=foo))"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_27_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_35_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { - std::array str_tmp_2 {"c"}; + std::array str_tmp_1 {"Y"}; if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { r.matched = false; break; @@ -6429,7 +7417,7 @@ int i{0}; { int i{0}; for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { - if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} } } if (r.matched) {r.pos += 1;} @@ -6444,16 +7432,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_27_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_35_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { - std::array str_tmp_1 {"b"}; + std::array str_tmp_0 {"X"}; if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { r.matched = false; break; @@ -6461,60 +7450,64 @@ int i{0}; { int i{0}; for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { - if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} } } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_2()))) {r.matched = false;break;} } while ( false ); if (r.matched) { - r = other(r.pos, ctx); + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_2(), cpp2::regex::no_reset(), other, func_3()); } else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_27_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_35_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { - std::array str_tmp_0 {"a"}; - if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + std::array str_tmp_2 {"foo"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { r.matched = false; break; } { int i{0}; - for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { - if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} } } - if (r.matched) {r.pos += 1;} + if (r.matched) {r.pos += 3;} else {break;} - if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} - ctx.set_group_start(1, r.pos); - if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} - if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} - ctx.set_group_end(1, r.pos); - - auto tmp_3_func { -[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ - if (!((*cpp2::impl::assert_not_null(_1)).matched)) { - (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; } - }; - auto tmp_3 {cpp2::regex::make_on_return(cpp2::move(tmp_3_func))}; - static_cast(cpp2::move(tmp_3)); + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_35_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} } while ( false @@ -6525,10 +7518,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_27_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_35_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6536,24 +7530,24 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_27_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_35_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_27_matcher::to_string() -> std::string{return R"(a(?!b(?!c))(..))"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_35_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_35_matcher::to_string() -> std::string{return R"((?=XY*foo))"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_28_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_36_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { - std::array str_tmp_2 {"a"}; + std::array str_tmp_1 {"Y"}; if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { r.matched = false; break; @@ -6561,7 +7555,7 @@ int i{0}; { int i{0}; for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { - if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} } } if (r.matched) {r.pos += 1;} @@ -6576,16 +7570,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_28_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_36_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { - std::array str_tmp_1 {"b"}; + std::array str_tmp_0 {"X"}; if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { r.matched = false; break; @@ -6593,60 +7588,65 @@ int i{0}; { int i{0}; for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { - if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} } } if (r.matched) {r.pos += 1;} else {break;} - if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_2()))) {r.matched = false;break;} } while ( false ); if (r.matched) { - r = other(r.pos, ctx); + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_2(), cpp2::regex::no_reset(), other, func_3()); } else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_28_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_36_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { - std::array str_tmp_0 {"a"}; - if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + std::array str_tmp_2 {"foo"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { r.matched = false; break; } { int i{0}; - for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { - if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} } } - if (r.matched) {r.pos += 1;} + if (r.matched) {r.pos += 3;} else {break;} - if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} - ctx.set_group_start(1, r.pos); - if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} - if (!(cpp2::regex::any_token_matcher(r.pos, ctx))) {r.matched = false;break;} - ctx.set_group_end(1, r.pos); - - auto tmp_3_func { -[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ - if (!((*cpp2::impl::assert_not_null(_1)).matched)) { - (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; } - }; - auto tmp_3 {cpp2::regex::make_on_return(cpp2::move(tmp_3_func))}; - static_cast(cpp2::move(tmp_3)); + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_36_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::line_start_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::lookahead_token_matcher(r.pos, ctx, func_1()))) {r.matched = false;break;} } while ( false @@ -6657,10 +7657,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_28_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_36_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6668,19 +7669,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_28_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_36_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_28_matcher::to_string() -> std::string{return R"(a(?!b(?=a))(..))"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_36_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_36_matcher::to_string() -> std::string{return R"(^(?=XY*foo))"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6695,11 +7696,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6728,11 +7730,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6747,11 +7750,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6778,16 +7782,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_19_lookahead::regex_37_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_19_lookahead::regex_37_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6802,11 +7807,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6835,11 +7841,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6865,16 +7872,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_19_lookahead::regex_37_matcher::wrap::reset_1::operator()(auto& ctx) const& -> void{ + template auto test_tests_19_lookahead::regex_37_matcher::reset_1::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(2); } - template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6888,11 +7896,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6906,10 +7915,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -6917,19 +7927,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::to_string() -> std::string{return R"(X(\w+)(?=\s)|X(\w+))"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_37_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_37_matcher::to_string() -> std::string{return R"(X(\w+)(?=\s)|X(\w+))"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_38_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_38_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6957,11 +7967,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_38_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_38_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -6976,11 +7987,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_38_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_38_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7008,11 +8020,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_38_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_38_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7041,10 +8054,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_38_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_38_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7052,19 +8066,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_38_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_38_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_38_matcher::to_string() -> std::string{return R"(^a*(?=b)b)"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_38_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_38_matcher::to_string() -> std::string{return R"(^a*(?=b)b)"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_39_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_39_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7079,11 +8093,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_39_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_39_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7112,10 +8127,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_39_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_39_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7123,19 +8139,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_39_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_39_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_39_matcher::to_string() -> std::string{return R"('(?!\A)x'm)"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_39_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_39_matcher::to_string() -> std::string{return R"('(?!\A)x'm)"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_40_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_40_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7150,11 +8166,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_40_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_40_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7168,15 +8185,16 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_40_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_40_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { - if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} + if (!(cpp2::regex::group_ref_token_matcher(r.pos, ctx))) {r.matched = false;break;} } while ( false @@ -7187,11 +8205,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_40_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_40_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7236,10 +8255,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_40_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_40_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7247,19 +8267,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_40_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_40_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_40_matcher::to_string() -> std::string{return R"('^(o)(?!.*\1)'i)"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_40_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_40_matcher::to_string() -> std::string{return R"('^(o)(?!.*\1)'i)"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7274,11 +8294,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7292,11 +8313,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7324,11 +8346,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7356,11 +8379,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7375,11 +8399,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7405,16 +8430,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_19_lookahead::regex_41_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_19_lookahead::regex_41_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7428,11 +8454,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7460,11 +8487,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::wrap::func_9::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::func_9::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7479,11 +8507,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7512,11 +8541,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::wrap::func_10::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::func_10::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7544,10 +8574,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7555,19 +8586,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::to_string() -> std::string{return R"(.*a(?!(b|cd)*e).*f)"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_41_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_41_matcher::to_string() -> std::string{return R"(.*a(?!(b|cd)*e).*f)"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7595,11 +8626,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7615,11 +8647,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7647,11 +8680,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7679,11 +8713,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7698,11 +8733,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7728,16 +8764,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_19_lookahead::regex_42_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_19_lookahead::regex_42_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(2); } - template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7751,11 +8788,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7770,11 +8808,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7801,10 +8840,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -7812,19 +8852,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::to_string() -> std::string{return R"(^(a*?)(?!(aa|aaaa)*$))"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_42_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_42_matcher::to_string() -> std::string{return R"(^(a*?)(?!(aa|aaaa)*$))"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7838,11 +8878,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7857,11 +8898,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7875,11 +8917,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7893,11 +8936,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7912,11 +8956,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7931,11 +8976,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7961,16 +9007,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_19_lookahead::regex_43_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_19_lookahead::regex_43_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -7984,11 +9031,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8002,10 +9050,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8013,19 +9062,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::to_string() -> std::string{return R"((?!)+?|(.{2,4}))"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_43_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_43_matcher::to_string() -> std::string{return R"((?!)+?|(.{2,4}))"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8053,11 +9102,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8073,11 +9123,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8105,11 +9156,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8123,11 +9175,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8141,11 +9194,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::wrap::func_9::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::func_9::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8173,11 +9227,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8191,11 +9246,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::wrap::func_10::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::func_10::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8209,11 +9265,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8228,11 +9285,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::wrap::func_11::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::func_11::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8258,16 +9316,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_19_lookahead::regex_44_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_19_lookahead::regex_44_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(2); } - template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8281,11 +9340,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::wrap::func_12::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::func_12::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8300,11 +9360,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8331,10 +9392,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8342,19 +9404,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::to_string() -> std::string{return R"(^(a*?)(?!(a{6}|a{5})*$))"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_44_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_44_matcher::to_string() -> std::string{return R"(^(a*?)(?!(a{6}|a{5})*$))"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_45_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_45_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8382,11 +9444,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_45_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_45_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8415,11 +9478,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_45_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_45_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8448,11 +9512,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_45_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_45_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8481,11 +9546,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_45_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_45_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8531,10 +9597,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_45_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_45_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8542,19 +9609,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_45_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_45_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_45_matcher::to_string() -> std::string{return R"(a(?!b(?!c(?!d(?!e))))...(.))"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_45_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_45_matcher::to_string() -> std::string{return R"(a(?!b(?!c(?!d(?!e))))...(.))"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8582,11 +9649,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8600,11 +9668,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::wrap::func_6::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8632,11 +9701,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::wrap::func_5::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8651,11 +9721,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::wrap::func_7::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8681,16 +9752,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_19_lookahead::regex_46_matcher::wrap::reset_0::operator()(auto& ctx) const& -> void{ + template auto test_tests_19_lookahead::regex_46_matcher::reset_0::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(1); } - template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::wrap::func_4::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8704,11 +9776,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::wrap::func_11::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::func_11::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8736,11 +9809,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::wrap::func_10::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::func_10::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8755,11 +9829,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::wrap::func_12::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::func_12::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8785,16 +9860,17 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template auto test_tests_19_lookahead::regex_46_matcher::wrap::reset_1::operator()(auto& ctx) const& -> void{ + template auto test_tests_19_lookahead::regex_46_matcher::reset_1::operator()(auto& ctx) const& -> void{ ctx.set_group_invalid(2); } - template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::wrap::func_9::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::func_9::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8808,11 +9884,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::wrap::func_13::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::func_13::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8840,11 +9917,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::wrap::func_8::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8859,11 +9937,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8878,11 +9957,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::wrap::func_14::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::func_14::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8897,11 +9977,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8930,11 +10011,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::wrap::func_15::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::func_15::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -8962,10 +10044,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -8973,19 +10056,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::to_string() -> std::string{return R"(X(?!b+(?!(c+)*(?!(c+)*d))).*X)"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_46_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_46_matcher::to_string() -> std::string{return R"(X(?!b+(?!(c+)*(?!(c+)*d))).*X)"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_47_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_47_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9000,11 +10083,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_47_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_47_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9047,10 +10131,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_47_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_47_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9058,19 +10143,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_47_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_47_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_47_matcher::to_string() -> std::string{return R"(((?s).)c(?!.))"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_47_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_47_matcher::to_string() -> std::string{return R"(((?s).)c(?!.))"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_48_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_48_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9085,11 +10170,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_48_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_48_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9132,10 +10218,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_48_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_48_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9143,19 +10230,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_48_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_48_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_48_matcher::to_string() -> std::string{return R"(((?s).)c(?!.))"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_48_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_48_matcher::to_string() -> std::string{return R"(((?s).)c(?!.))"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_49_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_49_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9170,11 +10257,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_49_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_49_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9231,10 +10319,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_49_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_49_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9242,19 +10331,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_49_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_49_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_49_matcher::to_string() -> std::string{return R"(((?s)b.)c(?!.))"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_49_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_49_matcher::to_string() -> std::string{return R"(((?s)b.)c(?!.))"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_50_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_50_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9269,11 +10358,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_50_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_50_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9330,10 +10420,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_50_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_50_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9341,19 +10432,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_50_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_50_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_50_matcher::to_string() -> std::string{return R"(((?s)b.)c(?!.))"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_50_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_50_matcher::to_string() -> std::string{return R"(((?s)b.)c(?!.))"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_51_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_51_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9368,11 +10459,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_51_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_51_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9429,10 +10521,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_51_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_51_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9440,19 +10533,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_51_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_51_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_51_matcher::to_string() -> std::string{return R"(((?s)b.)c(?!\N))"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_51_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_51_matcher::to_string() -> std::string{return R"(((?s)b.)c(?!\N))"; } - - template [[nodiscard]] auto test_tests_19_lookahead::regex_52_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_52_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9467,11 +10560,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_52_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_52_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9528,10 +10622,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_52_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_52_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9539,19 +10634,19 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_52_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_52_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_52_matcher::to_string() -> std::string{return R"('(b.)c(?!\N)'s)"; } - + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_52_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_52_matcher::to_string() -> std::string{return R"('(b.)c(?!\N)'s)"; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_53_matcher::wrap::func_1::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_53_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9579,11 +10674,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_53_matcher::wrap::func_0::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_53_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9597,11 +10693,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_53_matcher::wrap::func_3::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_53_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9615,11 +10712,12 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_53_matcher::wrap::func_2::operator()(cpp2::impl::in cur, context& ctx, auto const& other) const& -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_53_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ auto r {ctx.pass(cur)}; do { @@ -9634,10 +10732,11 @@ int i{0}; else { r.pos = ctx.end; } + static_cast(CPP2_FORWARD(ctx)); return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_53_matcher::wrap::entry(cpp2::impl::in cur, context& ctx) -> cpp2::regex::match_return{ + template template [[nodiscard]] auto test_tests_19_lookahead::regex_53_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ ctx.set_group_start(0, cur); auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; @@ -9645,15 +10744,158 @@ int i{0}; return r; } - template [[nodiscard]] auto test_tests_19_lookahead::regex_53_matcher::wrap::get_named_group_index(auto const& name) -> int{ + template [[nodiscard]] auto test_tests_19_lookahead::regex_53_matcher::get_named_group_index(auto const& name) -> int{ static_cast(name); return -1; } - [[nodiscard]] auto test_tests_19_lookahead::regex_53_matcher::to_string() -> std::string{return R"(a*(?!))"; } + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_53_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_53_matcher::to_string() -> std::string{return R"(a*(?!))"; } + + + + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_54_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + ctx.set_group_end(1, r.pos); + + auto tmp_0_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_0 {cpp2::regex::make_on_return(cpp2::move(tmp_0_func))}; + static_cast(cpp2::move(tmp_0)); + + std::array str_tmp_1 {"foo"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_54_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_19_lookahead::regex_54_matcher::get_named_group_index(auto const& name) -> int{ + if (name == "bar") {return 1; }else {return -1; } + } + + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_54_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_54_matcher::to_string() -> std::string{return R"((?)foo)"; } + + + + + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_55_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + + std::array str_tmp_0 {"ABC"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + ctx.set_group_end(1, r.pos); + + auto tmp_1_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_1 {cpp2::regex::make_on_return(cpp2::move(tmp_1_func))}; + static_cast(cpp2::move(tmp_1)); + + std::array str_tmp_2 {"foo"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),3)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,3); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 3;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_19_lookahead::regex_55_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_19_lookahead::regex_55_matcher::get_named_group_index(auto const& name) -> int{ + if (name == "bar") {return 1; }else {return -1; } + } + + template [[nodiscard]] constexpr auto test_tests_19_lookahead::regex_55_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_19_lookahead::regex_55_matcher::to_string() -> std::string{return R"((?ABC)foo)"; } -#line 261 "pure2-regex_19_lookahead.cpp2" +#line 282 "pure2-regex_19_lookahead.cpp2" auto main() -> int{ CPP2_UFCS(run)(test_tests_19_lookahead()); } diff --git a/regression-tests/test-results/pure2-regex_20_lookbehind.cpp.output b/regression-tests/test-results/pure2-regex_20_lookbehind.cpp.output new file mode 100644 index 0000000000..5ab1d4460f --- /dev/null +++ b/regression-tests/test-results/pure2-regex_20_lookbehind.cpp.output @@ -0,0 +1,3 @@ +pure2-regex_20_lookbehind.cpp... +pure2-regex_20_lookbehind.cpp: error: source filename must end with .cpp2 or .h2: pure2-regex_20_lookbehind.cpp + diff --git a/regression-tests/test-results/pure2-regex_21_atomic_patterns.cpp b/regression-tests/test-results/pure2-regex_21_atomic_patterns.cpp new file mode 100644 index 0000000000..f2a28f043d --- /dev/null +++ b/regression-tests/test-results/pure2-regex_21_atomic_patterns.cpp @@ -0,0 +1,1616 @@ + +#define CPP2_IMPORT_STD Yes +#include "cpp2regex.h" + +//=== Cpp2 type declarations ==================================================== + + +#include "cpp2util.h" + +#line 1 "pure2-regex_21_atomic_patterns.cpp2" + +#line 166 "pure2-regex_21_atomic_patterns.cpp2" +class test_tests_21_atomic_patterns; + + +//=== Cpp2 type definitions and function declarations =========================== + +#line 1 "pure2-regex_21_atomic_patterns.cpp2" +[[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string; + +#line 113 "pure2-regex_21_atomic_patterns.cpp2" +[[nodiscard]] auto sanitize(std::string str) -> std::string; + +#line 125 "pure2-regex_21_atomic_patterns.cpp2" +template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, + cpp2::impl::in resultExpected) -> void; + +#line 166 "pure2-regex_21_atomic_patterns.cpp2" +class test_tests_21_atomic_patterns { + +#line 173 "pure2-regex_21_atomic_patterns.cpp2" + public: auto run() const& -> void; + public: template class regex_01_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_4 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_01_matcher() = default; + public: regex_01_matcher(regex_01_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_01_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_01 {}; public: template class regex_02_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_4 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_02_matcher() = default; + public: regex_02_matcher(regex_02_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_02_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_02 {}; public: template class regex_03_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_4 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_03_matcher() = default; + public: regex_03_matcher(regex_03_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_03_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_03 {}; public: template class regex_04_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_4 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_5 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_6 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_8 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_7 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_9 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_10 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class reset_0 { + public: auto operator()(auto& ctx) const& -> void; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_11 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_04_matcher() = default; + public: regex_04_matcher(regex_04_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_04_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_04 {}; public: template class regex_05_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_4 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_05_matcher() = default; + public: regex_05_matcher(regex_05_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_05_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_05 {}; public: template class regex_06_matcher { + public: template using context = cpp2::regex::match_context; +public: class func_3 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_2 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_4 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_1 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_5 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_0 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: class func_6 { + public: template [[nodiscard]] auto operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return; + + }; + + public: template [[nodiscard]] static auto entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return; + + public: [[nodiscard]] static auto get_named_group_index(auto const& name) -> int; + + public: [[nodiscard]] constexpr static auto is_start_match() -> bool; +public: [[nodiscard]] static auto to_string() -> std::string; + + public: regex_06_matcher() = default; + public: regex_06_matcher(regex_06_matcher const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(regex_06_matcher const&) -> void = delete; + + }; + + public: cpp2::regex::regular_expression> regex_06 {}; + public: test_tests_21_atomic_patterns() = default; + public: test_tests_21_atomic_patterns(test_tests_21_atomic_patterns const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(test_tests_21_atomic_patterns const&) -> void = delete; + + +#line 183 "pure2-regex_21_atomic_patterns.cpp2" +}; +auto main() -> int; + +//=== Cpp2 function definitions ================================================= + +#line 1 "pure2-regex_21_atomic_patterns.cpp2" +[[nodiscard]] auto create_result(cpp2::impl::in resultExpr, auto const& r) -> std::string{ +#line 2 "pure2-regex_21_atomic_patterns.cpp2" + std::string result {""}; + + auto get_next {[_0 = (&resultExpr)](auto const& iter) mutable -> auto{ + auto start {std::distance(CPP2_UFCS(cbegin)((*cpp2::impl::assert_not_null(_0))), iter)}; + auto firstDollar {CPP2_UFCS(find)((*cpp2::impl::assert_not_null(_0)), "$", start)}; + auto firstAt {CPP2_UFCS(find)((*cpp2::impl::assert_not_null(_0)), "@", cpp2::move(start))}; + + auto end {std::min(cpp2::move(firstDollar), cpp2::move(firstAt))}; + if (end != std::string::npos) { + return CPP2_UFCS(cbegin)((*cpp2::impl::assert_not_null(_0))) + cpp2::move(end); + } + else { + return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); + } + }}; + auto extract_group_and_advance {[](auto& iter) -> auto{ + auto start {iter}; + + for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {} + + return std::stoi(std::string(cpp2::move(start), iter)); + }}; + auto extract_until {[](auto& iter, cpp2::impl::in to) -> auto{ + auto start {iter}; + + for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication) + + return std::string(cpp2::move(start), iter); + }}; + + auto iter {CPP2_UFCS(begin)(resultExpr)}; + + while( iter != CPP2_UFCS(end)(resultExpr) ) { + auto next {get_next(iter)}; + + if (next != iter) { + result += std::string(iter, next); + } + if (next != CPP2_UFCS(end)(resultExpr)) { + if (*cpp2::impl::assert_not_null(next) == '$') { + ++next; + + if (*cpp2::impl::assert_not_null(next) == '&') { + ++next; + result += CPP2_UFCS(group)(r, 0); + } + else {if (*cpp2::impl::assert_not_null(next) == '-' || *cpp2::impl::assert_not_null(next) == '+') { + auto is_start {*cpp2::impl::assert_not_null(next) == '-'}; + ++next; + if (*cpp2::impl::assert_not_null(next) == '{') { + ++next; // Skip { + auto group {extract_until(next, '}')}; + ++next; // Skip } + result += CPP2_UFCS(group)(r, cpp2::move(group)); + } + else {if (*cpp2::impl::assert_not_null(next) == '[') { + ++next; // Skip [ + auto group {extract_group_and_advance(next)}; + ++next; // Skip ] + + if (cpp2::move(is_start)) { + result += std::to_string(CPP2_UFCS(group_start)(r, cpp2::move(group))); + } + else { + result += std::to_string(CPP2_UFCS(group_end)(r, cpp2::move(group))); + } + } + else { + // Return max group + result += CPP2_UFCS(group)(r, CPP2_UFCS(group_number)(r) - 1); + }} + } + else {if (std::isdigit(*cpp2::impl::assert_not_null(next))) { + auto group {extract_group_and_advance(next)}; + result += CPP2_UFCS(group)(r, cpp2::move(group)); + } + else { + std::cerr << "Not implemented"; + }}} + } + else {if (*cpp2::impl::assert_not_null(next) == '@') { + ++next; + + if (*cpp2::impl::assert_not_null(next) == '-' || *cpp2::impl::assert_not_null(next) == '+') { + auto i {0}; + for( ; cpp2::impl::cmp_less(i,cpp2::unchecked_narrow(CPP2_UFCS(group_number)(r))); ++i ) { + auto pos {0}; + if (*cpp2::impl::assert_not_null(next) == '-') { + pos = CPP2_UFCS(group_start)(r, i); + } + else { + pos = CPP2_UFCS(group_end)(r, i); + } + result += std::to_string(cpp2::move(pos)); + } + ++next; + } + else { + std::cerr << "Not implemented"; + } + } + else { + std::cerr << "Not implemented."; + }} + } + iter = cpp2::move(next); + } + + return result; +} + +#line 113 "pure2-regex_21_atomic_patterns.cpp2" +[[nodiscard]] auto sanitize(std::string str) -> std::string +{ + str = cpp2::string_util::replace_all(str, "\a", "\\a"); + str = cpp2::string_util::replace_all(str, "\f", "\\f"); + str = cpp2::string_util::replace_all(str, "\x1b", "\\e"); + str = cpp2::string_util::replace_all(str, "\n", "\\n"); + str = cpp2::string_util::replace_all(str, "\r", "\\r"); + str = cpp2::string_util::replace_all(str, "\t", "\\t"); + + return cpp2::move(str); +} + +#line 125 "pure2-regex_21_atomic_patterns.cpp2" +template auto test(M const& regex, cpp2::impl::in id, cpp2::impl::in regex_str, cpp2::impl::in str, cpp2::impl::in kind, cpp2::impl::in resultExpr, + cpp2::impl::in resultExpected) -> void{ + + std::string warning {""}; + if (CPP2_UFCS(to_string)(regex) != regex_str) { + warning = "Warning: Parsed regex does not match."; + } + + std::string status {"OK"}; + + auto r {CPP2_UFCS(search)(regex, str)}; + + if ("y" == kind || "yM" == kind || "yS" == kind || "yB" == kind) { + if (!(r.matched)) { + status = "Failure: Regex should apply."; + } + else { + // Have a match check the result + + auto result {create_result(resultExpr, cpp2::move(r))}; + + if (result != resultExpected) { + status = "Failure: Result is wrong. (is: " + cpp2::to_string(sanitize(cpp2::move(result))) + ")"; + } + } + } + else {if ("n" == kind) { + if (r.matched) { + status = "Failure: Regex should not apply. Result is '" + cpp2::to_string(CPP2_UFCS(group)(cpp2::move(r), 0)) + "'"; + } + }else { + status = "Unknown kind '" + cpp2::to_string(kind) + "'"; + }} + + if (!(CPP2_UFCS(empty)(warning))) { + warning += " "; + } + std::cout << "" + cpp2::to_string(id) + "_" + cpp2::to_string(kind) + ": " + cpp2::to_string(cpp2::move(status)) + " " + cpp2::to_string(cpp2::move(warning)) + "regex: " + cpp2::to_string(regex_str) + " parsed_regex: " + cpp2::to_string(CPP2_UFCS(to_string)(regex)) + " str: " + cpp2::to_string(sanitize(str)) + " result_expr: " + cpp2::to_string(resultExpr) + " expected_results " + cpp2::to_string(sanitize(resultExpected)) + "" << std::endl; +} + +#line 173 "pure2-regex_21_atomic_patterns.cpp2" + auto test_tests_21_atomic_patterns::run() const& -> void{ + std::cout << "Running tests_21_atomic_patterns:" << std::endl; + test(regex_01, "01", R"((?>a+)b)", "aaab", "y", R"(-)", "-"); + test(regex_02, "02", R"(((?>a+)b))", "aaab", "y", R"($1)", "aaab"); + test(regex_03, "03", R"((?>(a+))b)", "aaab", "y", R"($1)", "aaa"); + test(regex_04, "04", R"(((?>[^()]+)|\([^()]*\))+)", "((abc(ade)ufh()()x", "y", R"($&)", "abc(ade)ufh()()x"); + test(regex_05, "05", R"(round\(((?>[^()]+))\))", "_I(round(xs * sz),1)", "y", R"($1)", "xs * sz"); + test(regex_06, "06", R"(^((?>(?:aa)?b)?))", "aab", "y", R"($1)", "aab"); + std::cout << std::endl; + } + + + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_01_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"a"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_01_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_2(), cpp2::regex::no_reset(), other, func_3()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_01_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_01_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::atomic_group_matcher(r.pos, ctx, func_1(), other, func_4()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_01_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_01_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_01_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_21_atomic_patterns::regex_01_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_01_matcher::to_string() -> std::string{return R"((?>a+)b)"; } + + + + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_02_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"a"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_02_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_2(), cpp2::regex::no_reset(), other, func_3()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_02_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_02_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::atomic_group_matcher(r.pos, ctx, func_1(), other, func_4()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_02_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + ctx.set_group_end(1, r.pos); + + auto tmp_2_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_2 {cpp2::regex::make_on_return(cpp2::move(tmp_2_func))}; + static_cast(cpp2::move(tmp_2)); + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_02_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_02_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_21_atomic_patterns::regex_02_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_02_matcher::to_string() -> std::string{return R"(((?>a+)b))"; } + + + + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_03_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"a"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_03_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_2(), cpp2::regex::no_reset(), other, func_3()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_03_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_1_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_1 {cpp2::regex::make_on_return(cpp2::move(tmp_1_func))}; + static_cast(cpp2::move(tmp_1)); + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_03_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::atomic_group_matcher(r.pos, ctx, func_1(), other, func_4()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_03_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_2 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_03_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_03_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_21_atomic_patterns::regex_03_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_03_matcher::to_string() -> std::string{return R"((?>(a+))b)"; } + + + + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_04_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::class_token_matcher,::cpp2::regex::single_class_entry>::match(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_04_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_4(), cpp2::regex::no_reset(), other, func_5()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_04_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_04_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::atomic_group_matcher(r.pos, ctx, func_3(), other, func_6()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_04_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_04_matcher::func_8::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::class_token_matcher,::cpp2::regex::single_class_entry>::match(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_04_matcher::func_7::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"("}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_8(), cpp2::regex::no_reset(), other, func_9()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_04_matcher::func_9::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {")"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_04_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::alternative_token_matcher::match(r.pos, ctx, other, func_10(), func_2(), cpp2::regex::no_reset(), func_7(), cpp2::regex::no_reset()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_04_matcher::func_10::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_2_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_2 {cpp2::regex::make_on_return(cpp2::move(tmp_2_func))}; + static_cast(cpp2::move(tmp_2)); + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template auto test_tests_21_atomic_patterns::regex_04_matcher::reset_0::operator()(auto& ctx) const& -> void{ + ctx.set_group_invalid(1); + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_04_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), reset_0(), other, func_11()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_04_matcher::func_11::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_04_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_04_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_21_atomic_patterns::regex_04_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_04_matcher::to_string() -> std::string{return R"(((?>[^()]+)|\([^()]*\))+)"; } + + + + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_05_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::class_token_matcher,::cpp2::regex::single_class_entry>::match(r.pos, ctx))) {r.matched = false;break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_05_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_2(), cpp2::regex::no_reset(), other, func_3()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_05_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_05_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"round("}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),6)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,6); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 6;} + else {break;} + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::atomic_group_matcher(r.pos, ctx, func_1(), other, func_4()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_05_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_1_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_1 {cpp2::regex::make_on_return(cpp2::move(tmp_1_func))}; + static_cast(cpp2::move(tmp_1)); + + std::array str_tmp_2 {")"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_2, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_05_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_05_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_21_atomic_patterns::regex_05_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_05_matcher::to_string() -> std::string{return R"(round\(((?>[^()]+))\))"; } + + + + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_06_matcher::func_3::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_0 {"aa"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),2)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,2); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_0, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 2;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_06_matcher::func_2::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_3(), cpp2::regex::no_reset(), other, func_4()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_06_matcher::func_4::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + + std::array str_tmp_1 {"b"}; + if (cpp2::impl::cmp_less(std::distance(r.pos, ctx.end),1)) { + r.matched = false; + break; + } +{ +int i{0}; + for( ; cpp2::impl::cmp_less(i,1); (i += 1) ) { + if (CPP2_ASSERT_IN_BOUNDS(str_tmp_1, i) != CPP2_ASSERT_IN_BOUNDS(r.pos, i)) {r.matched = false;} + } +} + if (r.matched) {r.pos += 1;} + else {break;} + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_06_matcher::func_1::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::atomic_group_matcher(r.pos, ctx, func_2(), other, func_5()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_06_matcher::func_5::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_06_matcher::func_0::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + if (!(cpp2::regex::line_start_token_matcher(r.pos, ctx))) {r.matched = false;break;} + ctx.set_group_start(1, r.pos); + } + while ( + false + ); + if (r.matched) { + r = cpp2::regex::range_token_matcher::match(r.pos, ctx, func_1(), cpp2::regex::no_reset(), other, func_6()); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_06_matcher::func_6::operator()(Iter const& cur, auto&& ctx, auto const& other) const& -> cpp2::regex::match_return{ + + auto r {ctx.pass(cur)}; + do { + ctx.set_group_end(1, r.pos); + + auto tmp_2_func { +[&, _1 = (&r), _2 = (&ctx)]() mutable -> void{ + if (!((*cpp2::impl::assert_not_null(_1)).matched)) { + (*cpp2::impl::assert_not_null(_2)).set_group_invalid(1); + } + } + }; + + auto tmp_2 {cpp2::regex::make_on_return(cpp2::move(tmp_2_func))}; + static_cast(cpp2::move(tmp_2)); + } + while ( + false + ); + if (r.matched) { + r = other(r.pos, ctx); + } + else { + r.pos = ctx.end; + } + static_cast(CPP2_FORWARD(ctx)); + return r; + } + + template template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_06_matcher::entry(Iter const& cur, context& ctx) -> cpp2::regex::match_return{ + ctx.set_group_start(0, cur); + + auto r {func_0()(cur, ctx, cpp2::regex::true_end_func())}; + if (r.matched) {ctx.set_group_end(0, r.pos);} + return r; + } + + template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_06_matcher::get_named_group_index(auto const& name) -> int{ + static_cast(name); + return -1; + } + + template [[nodiscard]] constexpr auto test_tests_21_atomic_patterns::regex_06_matcher::is_start_match() -> bool { return false; } +template [[nodiscard]] auto test_tests_21_atomic_patterns::regex_06_matcher::to_string() -> std::string{return R"(^((?>(?:aa)?b)?))"; } + + +#line 184 "pure2-regex_21_atomic_patterns.cpp2" +auto main() -> int{ + CPP2_UFCS(run)(test_tests_21_atomic_patterns()); +} + diff --git a/regression-tests/test-results/pure2-regex_21_atomic_patterns.cpp2.output b/regression-tests/test-results/pure2-regex_21_atomic_patterns.cpp2.output new file mode 100644 index 0000000000..1e1125c3c4 --- /dev/null +++ b/regression-tests/test-results/pure2-regex_21_atomic_patterns.cpp2.output @@ -0,0 +1,2 @@ +pure2-regex_21_atomic_patterns.cpp2... ok (all Cpp2, passes safety checks) + diff --git a/source/reflect.h b/source/reflect.h index a9e8ab3369..645d0df0e1 100644 --- a/source/reflect.h +++ b/source/reflect.h @@ -51,68 +51,71 @@ class expression_flags; #line 1664 "reflect.h2" class regex_token; -#line 1690 "reflect.h2" +#line 1691 "reflect.h2" class regex_token_check; -#line 1709 "reflect.h2" +#line 1712 "reflect.h2" class regex_token_code; -#line 1728 "reflect.h2" +#line 1733 "reflect.h2" class regex_token_empty; -#line 1744 "reflect.h2" +#line 1751 "reflect.h2" class regex_token_list; -#line 1783 "reflect.h2" +#line 1803 "reflect.h2" class parse_context_group_state; -#line 1844 "reflect.h2" +#line 1864 "reflect.h2" class parse_context_branch_reset_state; -#line 1887 "reflect.h2" +#line 1907 "reflect.h2" class parse_context; -#line 2285 "reflect.h2" +#line 2308 "reflect.h2" class generation_function_context; -#line 2303 "reflect.h2" +#line 2326 "reflect.h2" class generation_context; -#line 2501 "reflect.h2" +#line 2525 "reflect.h2" class alternative_token; -#line 2516 "reflect.h2" +#line 2540 "reflect.h2" class alternative_token_gen; -#line 2568 "reflect.h2" +#line 2605 "reflect.h2" class any_token; -#line 2586 "reflect.h2" +#line 2622 "reflect.h2" +class atomic_group_token; + +#line 2652 "reflect.h2" class char_token; -#line 2689 "reflect.h2" +#line 2767 "reflect.h2" class class_token; -#line 2904 "reflect.h2" +#line 2991 "reflect.h2" class group_ref_token; -#line 3035 "reflect.h2" +#line 3128 "reflect.h2" class group_token; -#line 3322 "reflect.h2" -class lookahead_token; +#line 3475 "reflect.h2" +class lookahead_lookbehind_token; -#line 3403 "reflect.h2" +#line 3570 "reflect.h2" class range_token; -#line 3551 "reflect.h2" +#line 3727 "reflect.h2" class special_range_token; -#line 3618 "reflect.h2" +#line 3813 "reflect.h2" template class regex_generator; -#line 3866 "reflect.h2" +#line 4061 "reflect.h2" } } @@ -664,6 +667,7 @@ class regex_token #line 1677 "reflect.h2" public: virtual auto generate_code([[maybe_unused]] generation_context& unnamed_param_2) const -> void = 0; + public: [[nodiscard]] virtual auto reverse() const -> std::shared_ptr = 0; public: virtual auto add_groups([[maybe_unused]] std::set& unnamed_param_2) const -> void; public: [[nodiscard]] auto to_string() const& -> std::string; @@ -673,105 +677,114 @@ class regex_token public: regex_token(regex_token const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(regex_token const&) -> void = delete; -#line 1682 "reflect.h2" +#line 1683 "reflect.h2" }; using token_ptr = std::shared_ptr; using token_vec = std::vector; -#line 1688 "reflect.h2" +#line 1689 "reflect.h2" // Adds a check in code generation. // class regex_token_check : public regex_token { -#line 1694 "reflect.h2" +#line 1695 "reflect.h2" private: std::string check; public: regex_token_check(cpp2::impl::in str, cpp2::impl::in check_); -#line 1701 "reflect.h2" +#line 1702 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; + +#line 1706 "reflect.h2" + public: [[nodiscard]] auto reverse() const -> token_ptr override; public: virtual ~regex_token_check() noexcept; public: regex_token_check(regex_token_check const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(regex_token_check const&) -> void = delete; - -#line 1704 "reflect.h2" +#line 1707 "reflect.h2" }; -#line 1707 "reflect.h2" +#line 1710 "reflect.h2" // Adds code in code generation. // class regex_token_code : public regex_token { -#line 1713 "reflect.h2" +#line 1716 "reflect.h2" private: std::string code; public: regex_token_code(cpp2::impl::in str, cpp2::impl::in code_); -#line 1720 "reflect.h2" +#line 1723 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; + +#line 1727 "reflect.h2" + public: [[nodiscard]] auto reverse() const -> token_ptr override; public: virtual ~regex_token_code() noexcept; public: regex_token_code(regex_token_code const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(regex_token_code const&) -> void = delete; - -#line 1723 "reflect.h2" +#line 1728 "reflect.h2" }; -#line 1726 "reflect.h2" +#line 1731 "reflect.h2" // Token that does not influence the matching. E.g. comment. // class regex_token_empty : public regex_token { -#line 1732 "reflect.h2" +#line 1737 "reflect.h2" public: regex_token_empty(cpp2::impl::in str); -#line 1736 "reflect.h2" +#line 1741 "reflect.h2" public: auto generate_code([[maybe_unused]] generation_context& unnamed_param_2) const -> void override; + +#line 1745 "reflect.h2" + public: [[nodiscard]] auto reverse() const -> token_ptr override; public: virtual ~regex_token_empty() noexcept; public: regex_token_empty(regex_token_empty const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(regex_token_empty const&) -> void = delete; - -#line 1739 "reflect.h2" +#line 1746 "reflect.h2" }; -#line 1742 "reflect.h2" +#line 1749 "reflect.h2" // Represents a list of regex tokens as one token. // class regex_token_list : public regex_token { -#line 1748 "reflect.h2" +#line 1755 "reflect.h2" public: token_vec tokens; public: regex_token_list(cpp2::impl::in t); -#line 1755 "reflect.h2" +#line 1762 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; -#line 1761 "reflect.h2" +#line 1768 "reflect.h2" public: auto add_groups(std::set& groups) const -> void override; -#line 1767 "reflect.h2" +#line 1774 "reflect.h2" public: [[nodiscard]] static auto gen_string(cpp2::impl::in vec) -> std::string; + +#line 1782 "reflect.h2" + public: [[nodiscard]] auto reverse() const -> token_ptr override; public: virtual ~regex_token_list() noexcept; public: regex_token_list(regex_token_list const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(regex_token_list const&) -> void = delete; -#line 1774 "reflect.h2" +#line 1794 "reflect.h2" }; -#line 1777 "reflect.h2" +#line 1797 "reflect.h2" // // Parse and generation context. // @@ -787,33 +800,33 @@ class parse_context_group_state // Start a new alternative. public: auto next_alternative() & -> void; -#line 1797 "reflect.h2" +#line 1817 "reflect.h2" // Swap this state with the other one. NOLINTNEXTLINE(performance-noexcept-swap) public: auto swap(parse_context_group_state& t) & -> void; -#line 1804 "reflect.h2" +#line 1824 "reflect.h2" // Convert this state into a regex token. public: [[nodiscard]] auto get_as_token() & -> token_ptr; -#line 1816 "reflect.h2" +#line 1836 "reflect.h2" // Add a token to the current matcher list. public: auto add(cpp2::impl::in token) & -> void; -#line 1821 "reflect.h2" +#line 1841 "reflect.h2" // True if current matcher list is empty. public: [[nodiscard]] auto empty() const& -> bool; -#line 1825 "reflect.h2" +#line 1845 "reflect.h2" // Apply optimizations to the matcher list. public: static auto post_process_list(token_vec& list) -> void; public: parse_context_group_state(auto const& cur_match_list_, auto const& alternate_match_lists_, auto const& modifiers_); public: parse_context_group_state(); -#line 1839 "reflect.h2" +#line 1859 "reflect.h2" }; -#line 1842 "reflect.h2" +#line 1862 "reflect.h2" // State for the branch reset. Takes care of the group numbering. See '(|)'. // class parse_context_branch_reset_state @@ -826,25 +839,25 @@ class parse_context_branch_reset_state // Next group identifier. public: [[nodiscard]] auto next() & -> int; -#line 1860 "reflect.h2" +#line 1880 "reflect.h2" // Set next group identifier. public: auto set_next(cpp2::impl::in g) & -> void; -#line 1866 "reflect.h2" +#line 1886 "reflect.h2" // Start a new alternative branch. public: auto next_alternative() & -> void; -#line 1873 "reflect.h2" +#line 1893 "reflect.h2" // Initialize for a branch reset group. public: auto set_active_reset(cpp2::impl::in restart) & -> void; public: parse_context_branch_reset_state(auto const& is_active_, auto const& cur_group_, auto const& max_group_, auto const& from_); public: parse_context_branch_reset_state(); -#line 1880 "reflect.h2" +#line 1900 "reflect.h2" }; -#line 1883 "reflect.h2" +#line 1903 "reflect.h2" // Context during parsing of the regular expressions. // // Keeps track of the distributed group identifiers, current parsed group and branch resets. @@ -855,10 +868,12 @@ class parse_context private: size_t pos {0}; // Current parsing position. private: token_ptr root; // Token representing the regular expression. + public: bool is_start_match {false}; // If the regex contains \G at the beginning. + private: parse_context_group_state cur_group_state {}; private: parse_context_branch_reset_state cur_branch_reset_state {}; -#line 1897 "reflect.h2" +#line 1919 "reflect.h2" public: std::map named_groups {}; private: error_func error_out; // TODO: Declaring std::function fails for cpp2. @@ -866,64 +881,64 @@ class parse_context public: parse_context(cpp2::impl::in r, auto const& e); -#line 1908 "reflect.h2" +#line 1930 "reflect.h2" // State management functions // // Returned group state needs to be stored and provided in `end_group`. public: [[nodiscard]] auto start_group() & -> parse_context_group_state; -#line 1921 "reflect.h2" +#line 1943 "reflect.h2" // `old_state` argument needs to be from start group. public: [[nodiscard]] auto end_group(cpp2::impl::in old_state) & -> token_ptr; -#line 1929 "reflect.h2" +#line 1951 "reflect.h2" public: [[nodiscard]] auto get_modifiers() const& -> expression_flags; -#line 1933 "reflect.h2" +#line 1955 "reflect.h2" public: auto set_modifiers(cpp2::impl::in mod) & -> void; -#line 1937 "reflect.h2" +#line 1959 "reflect.h2" // Branch reset management functions // public: [[nodiscard]] auto branch_reset_new_state() & -> parse_context_branch_reset_state; -#line 1949 "reflect.h2" +#line 1971 "reflect.h2" public: auto branch_reset_restore_state(cpp2::impl::in old_state) & -> void; -#line 1956 "reflect.h2" +#line 1978 "reflect.h2" public: auto next_alternative() & -> void; -#line 1962 "reflect.h2" +#line 1984 "reflect.h2" // Regex token management // public: auto add_token(cpp2::impl::in token) & -> void; -#line 1968 "reflect.h2" +#line 1990 "reflect.h2" public: [[nodiscard]] auto has_token() const& -> bool; -#line 1972 "reflect.h2" +#line 1994 "reflect.h2" public: [[nodiscard]] auto pop_token() & -> token_ptr; -#line 1983 "reflect.h2" +#line 2005 "reflect.h2" public: [[nodiscard]] auto get_as_token() & -> token_ptr; -#line 1987 "reflect.h2" +#line 2009 "reflect.h2" // Group management // public: [[nodiscard]] auto get_cur_group() const& -> int; -#line 1993 "reflect.h2" +#line 2015 "reflect.h2" public: [[nodiscard]] auto next_group() & -> int; -#line 1997 "reflect.h2" +#line 2019 "reflect.h2" public: auto set_named_group(cpp2::impl::in name, cpp2::impl::in id) & -> void; -#line 2004 "reflect.h2" +#line 2026 "reflect.h2" public: [[nodiscard]] auto get_named_group(cpp2::impl::in name) const& -> int; -#line 2015 "reflect.h2" +#line 2037 "reflect.h2" // Position management functions // public: [[nodiscard]] auto current() const& -> char; @@ -931,51 +946,51 @@ class parse_context // Get the next token in the regex, skipping spaces according to the parameters. See `x` and `xx` modifiers. private: [[nodiscard]] auto get_next_position(cpp2::impl::in in_class, cpp2::impl::in no_skip) const& -> size_t; -#line 2059 "reflect.h2" +#line 2081 "reflect.h2" // Return true if next token is available. private: [[nodiscard]] auto next_impl(cpp2::impl::in in_class, cpp2::impl::in no_skip) & -> bool; -#line 2071 "reflect.h2" +#line 2093 "reflect.h2" public: [[nodiscard]] auto next() & -> decltype(auto); public: [[nodiscard]] auto next_in_class() & -> decltype(auto); public: [[nodiscard]] auto next_no_skip() & -> decltype(auto); public: [[nodiscard]] auto next_n(cpp2::impl::in n) & -> bool; -#line 2084 "reflect.h2" +#line 2106 "reflect.h2" public: [[nodiscard]] auto has_next() const& -> bool; private: [[nodiscard]] auto grab_until_impl(cpp2::impl::in e, cpp2::impl::out r, cpp2::impl::in any) & -> bool; -#line 2107 "reflect.h2" +#line 2129 "reflect.h2" public: [[nodiscard]] auto grab_until(cpp2::impl::in e, cpp2::impl::out r) & -> decltype(auto); public: [[nodiscard]] auto grab_until(cpp2::impl::in e, cpp2::impl::out r) & -> decltype(auto); public: [[nodiscard]] auto grab_until_one_of(cpp2::impl::in e, cpp2::impl::out r) & -> decltype(auto); public: [[nodiscard]] auto grab_n(cpp2::impl::in n, cpp2::impl::out r) & -> bool; -#line 2124 "reflect.h2" +#line 2146 "reflect.h2" public: [[nodiscard]] auto grab_number() & -> std::string; -#line 2145 "reflect.h2" +#line 2167 "reflect.h2" private: [[nodiscard]] auto peek_impl(cpp2::impl::in in_class) const& -> char; -#line 2155 "reflect.h2" +#line 2177 "reflect.h2" public: [[nodiscard]] auto peek() const& -> decltype(auto); public: [[nodiscard]] auto peek_in_class() const& -> decltype(auto); -#line 2159 "reflect.h2" +#line 2181 "reflect.h2" // Parsing functions // public: [[nodiscard]] auto parser_group_modifiers(cpp2::impl::in change_str, expression_flags& parser_modifiers) & -> bool; -#line 2215 "reflect.h2" +#line 2237 "reflect.h2" public: [[nodiscard]] auto parse_until(cpp2::impl::in term) & -> bool; -#line 2253 "reflect.h2" +#line 2276 "reflect.h2" public: [[nodiscard]] auto parse(cpp2::impl::in modifiers) & -> bool; -#line 2268 "reflect.h2" +#line 2291 "reflect.h2" // Misc functions public: [[nodiscard]] auto get_pos() const& -> decltype(auto); @@ -987,10 +1002,10 @@ class parse_context public: auto operator=(parse_context const&) -> void = delete; -#line 2279 "reflect.h2" +#line 2302 "reflect.h2" }; -#line 2282 "reflect.h2" +#line 2305 "reflect.h2" // Context for one function generation. Generation of functions can be interleaved, // therefore we buffer the code for one function here. // @@ -1000,16 +1015,16 @@ class generation_function_context { public: auto add_tabs(cpp2::impl::in c) & -> void; -#line 2296 "reflect.h2" +#line 2319 "reflect.h2" public: auto remove_tabs(cpp2::impl::in c) & -> void; public: generation_function_context(auto const& code_, auto const& tabs_); public: generation_function_context(); -#line 2299 "reflect.h2" +#line 2322 "reflect.h2" }; -#line 2302 "reflect.h2" +#line 2325 "reflect.h2" // Context for generating the state machine. class generation_context { @@ -1029,68 +1044,68 @@ class generation_context // Add code line. public: auto add(cpp2::impl::in s) & -> void; -#line 2324 "reflect.h2" +#line 2347 "reflect.h2" // Add check for token. The check needs to be a function call that returns a boolean. public: auto add_check(cpp2::impl::in check) & -> void; -#line 2330 "reflect.h2" +#line 2353 "reflect.h2" // Add a stateful check. The check needs to return a `match_return`. public: auto add_statefull(cpp2::impl::in next_func, cpp2::impl::in check) & -> void; -#line 2339 "reflect.h2" +#line 2362 "reflect.h2" protected: auto start_func_named(cpp2::impl::in name) & -> void; -#line 2350 "reflect.h2" +#line 2373 "reflect.h2" protected: [[nodiscard]] auto start_func() & -> std::string; -#line 2357 "reflect.h2" +#line 2380 "reflect.h2" protected: auto end_func_statefull(cpp2::impl::in s) & -> void; -#line 2376 "reflect.h2" +#line 2400 "reflect.h2" // Generate the function for a token. public: [[nodiscard]] auto generate_func(cpp2::impl::in token) & -> std::string; -#line 2386 "reflect.h2" +#line 2410 "reflect.h2" // Generate the reset for a list of group identifiers. public: [[nodiscard]] auto generate_reset(cpp2::impl::in> groups) & -> std::string; -#line 2409 "reflect.h2" +#line 2433 "reflect.h2" // Name generation // protected: [[nodiscard]] auto gen_func_name() & -> std::string; -#line 2417 "reflect.h2" +#line 2441 "reflect.h2" public: [[nodiscard]] auto next_func_name() & -> std::string; -#line 2421 "reflect.h2" +#line 2445 "reflect.h2" protected: [[nodiscard]] auto gen_reset_func_name() & -> std::string; -#line 2427 "reflect.h2" +#line 2451 "reflect.h2" public: [[nodiscard]] auto gen_temp() & -> std::string; -#line 2433 "reflect.h2" +#line 2457 "reflect.h2" // Context management // public: [[nodiscard]] auto new_context() & -> generation_function_context*; -#line 2443 "reflect.h2" +#line 2467 "reflect.h2" public: auto finish_context() & -> void; -#line 2451 "reflect.h2" +#line 2475 "reflect.h2" // Misc functions // private: [[nodiscard]] auto get_current() & -> generation_function_context*; -#line 2457 "reflect.h2" +#line 2481 "reflect.h2" private: [[nodiscard]] auto get_base() & -> generation_function_context*; -#line 2461 "reflect.h2" +#line 2485 "reflect.h2" public: [[nodiscard]] auto get_entry_func() const& -> std::string; -#line 2465 "reflect.h2" +#line 2489 "reflect.h2" public: [[nodiscard]] auto create_named_group_lookup(cpp2::impl::in> named_groups) const& -> std::string; -#line 2489 "reflect.h2" +#line 2513 "reflect.h2" // Run the generation for the token. public: [[nodiscard]] auto run(cpp2::impl::in token) & -> std::string; public: generation_context() = default; @@ -1098,7 +1113,7 @@ class generation_context public: auto operator=(generation_context const&) -> void = delete; -#line 2495 "reflect.h2" +#line 2519 "reflect.h2" }; // Regex syntax: | Example: ab|ba @@ -1118,44 +1133,47 @@ class alternative_token public: auto operator=(alternative_token const&) -> void = delete; -#line 2514 "reflect.h2" +#line 2538 "reflect.h2" }; class alternative_token_gen : public regex_token { -#line 2520 "reflect.h2" +#line 2544 "reflect.h2" private: token_vec alternatives; public: alternative_token_gen(cpp2::impl::in a); -#line 2527 "reflect.h2" +#line 2551 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; -#line 2544 "reflect.h2" +#line 2568 "reflect.h2" public: auto add_groups(std::set& groups) const -> void override; -#line 2551 "reflect.h2" +#line 2575 "reflect.h2" public: [[nodiscard]] static auto gen_string(cpp2::impl::in a) -> std::string; + +#line 2588 "reflect.h2" + public: [[nodiscard]] auto reverse() const -> token_ptr override; public: virtual ~alternative_token_gen() noexcept; public: alternative_token_gen(alternative_token_gen const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(alternative_token_gen const&) -> void = delete; -#line 2563 "reflect.h2" +#line 2600 "reflect.h2" }; -#line 2566 "reflect.h2" +#line 2603 "reflect.h2" // Regex syntax: . // class any_token : public regex_token_check { -#line 2572 "reflect.h2" +#line 2609 "reflect.h2" public: any_token(cpp2::impl::in single_line); -#line 2576 "reflect.h2" +#line 2613 "reflect.h2" public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr; public: virtual ~any_token() noexcept; @@ -1163,37 +1181,68 @@ class any_token public: auto operator=(any_token const&) -> void = delete; -#line 2581 "reflect.h2" +#line 2618 "reflect.h2" +}; + +// Regex syntax: (?>) Example: a(?>bc|c)c +// +class atomic_group_token +: public regex_token { + +#line 2626 "reflect.h2" + public: token_ptr inner_token {nullptr}; + + public: explicit atomic_group_token(); + + public: [[nodiscard]] auto reverse() const -> token_ptr override; + +#line 2637 "reflect.h2" + public: auto generate_code(generation_context& ctx) const -> void override; + +#line 2645 "reflect.h2" + public: auto add_groups(std::set& groups) const -> void override; + public: virtual ~atomic_group_token() noexcept; + + public: atomic_group_token(atomic_group_token const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(atomic_group_token const&) -> void = delete; + + +#line 2648 "reflect.h2" }; -#line 2584 "reflect.h2" // Regex syntax: a // class char_token : public regex_token { -#line 2590 "reflect.h2" +#line 2656 "reflect.h2" private: std::string token; private: bool ignore_case; public: char_token(cpp2::impl::in t, cpp2::impl::in ignore_case_); -#line 2599 "reflect.h2" +#line 2665 "reflect.h2" + public: char_token(cpp2::impl::in t, cpp2::impl::in ignore_case_); + +#line 2671 "reflect.h2" public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr; -#line 2603 "reflect.h2" +#line 2675 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; -#line 2626 "reflect.h2" +#line 2698 "reflect.h2" public: auto gen_case_insensitive(cpp2::impl::in lower, cpp2::impl::in upper, generation_context& ctx) const& -> void; -#line 2647 "reflect.h2" +#line 2719 "reflect.h2" public: auto gen_case_sensitive(generation_context& ctx) const& -> void; -#line 2665 "reflect.h2" +#line 2737 "reflect.h2" public: [[nodiscard]] auto add_escapes(std::string str) const& -> std::string; -#line 2680 "reflect.h2" +#line 2752 "reflect.h2" + public: [[nodiscard]] auto reverse() const -> token_ptr override; + +#line 2758 "reflect.h2" public: auto append(char_token const& that) & -> void; public: virtual ~char_token() noexcept; @@ -1201,30 +1250,33 @@ class char_token public: auto operator=(char_token const&) -> void = delete; -#line 2684 "reflect.h2" +#line 2762 "reflect.h2" }; -#line 2687 "reflect.h2" +#line 2765 "reflect.h2" // Regex syntax: [] Example: [abcx-y[:digits:]] // class class_token : public regex_token { -#line 2693 "reflect.h2" +#line 2771 "reflect.h2" private: bool negate; private: bool case_insensitive; private: std::string class_str; public: class_token(cpp2::impl::in negate_, cpp2::impl::in case_insensitive_, cpp2::impl::in class_str_, cpp2::impl::in str); -#line 2705 "reflect.h2" +#line 2783 "reflect.h2" // TODO: Rework class generation: Generate check functions for classes. public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr; -#line 2831 "reflect.h2" +#line 2909 "reflect.h2" + public: [[nodiscard]] auto reverse() const -> token_ptr override; + +#line 2918 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; -#line 2836 "reflect.h2" +#line 2923 "reflect.h2" private: [[nodiscard]] static auto create_matcher(cpp2::impl::in name, cpp2::impl::in template_arguments) -> std::string; public: virtual ~class_token() noexcept; @@ -1232,20 +1284,20 @@ class class_token public: auto operator=(class_token const&) -> void = delete; -#line 2843 "reflect.h2" +#line 2930 "reflect.h2" }; -#line 2846 "reflect.h2" +#line 2933 "reflect.h2" // Regex syntax: \a or \n or \[ // [[nodiscard]] auto escape_token_parse(parse_context& ctx) -> token_ptr; -#line 2887 "reflect.h2" +#line 2974 "reflect.h2" // Regex syntax: \K Example: ab\Kcd // [[nodiscard]] auto global_group_reset_token_parse(parse_context& ctx) -> token_ptr; -#line 2898 "reflect.h2" +#line 2985 "reflect.h2" // Regex syntax: \ Example: \1 // \g{name_or_number} // \k{name_or_number} @@ -1255,16 +1307,20 @@ class class_token class group_ref_token : public regex_token { -#line 2908 "reflect.h2" +#line 2995 "reflect.h2" private: int id; private: bool case_insensitive; + private: bool reverse_eval; - public: group_ref_token(cpp2::impl::in id_, cpp2::impl::in case_insensitive_, cpp2::impl::in str); + public: group_ref_token(cpp2::impl::in id_, cpp2::impl::in case_insensitive_, cpp2::impl::in reverse_, cpp2::impl::in str); -#line 2918 "reflect.h2" +#line 3007 "reflect.h2" public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr; -#line 3019 "reflect.h2" +#line 3108 "reflect.h2" + public: [[nodiscard]] auto reverse() const -> token_ptr override; + +#line 3112 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; public: virtual ~group_ref_token() noexcept; @@ -1272,10 +1328,10 @@ class group_ref_token public: auto operator=(group_ref_token const&) -> void = delete; -#line 3022 "reflect.h2" +#line 3115 "reflect.h2" }; -#line 3025 "reflect.h2" +#line 3118 "reflect.h2" // Regex syntax: () Example: (abc) // (?:) (?i:abc) @@ -1289,22 +1345,29 @@ class group_ref_token class group_token : public regex_token { -#line 3039 "reflect.h2" +#line 3132 "reflect.h2" private: int number {-1}; + private: bool reverse_eval {false}; private: token_ptr inner {nullptr}; - public: [[nodiscard]] static auto parse_lookahead(parse_context& ctx, cpp2::impl::in syntax, cpp2::impl::in positive) -> token_ptr; + public: [[nodiscard]] static auto parse_lookahead_lookbehind(parse_context& ctx, cpp2::impl::in syntax, cpp2::impl::in lookahead, cpp2::impl::in positive) -> token_ptr; -#line 3056 "reflect.h2" +#line 3154 "reflect.h2" + public: [[nodiscard]] static auto parse_atomic_pattern(parse_context& ctx, cpp2::impl::in syntax) -> token_ptr; + +#line 3168 "reflect.h2" public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr; -#line 3193 "reflect.h2" +#line 3327 "reflect.h2" + public: [[nodiscard]] auto reverse() const -> token_ptr override; + +#line 3335 "reflect.h2" public: [[nodiscard]] static auto gen_string(cpp2::impl::in name, cpp2::impl::in name_brackets, cpp2::impl::in has_modifier, cpp2::impl::in modifiers, cpp2::impl::in inner_) -> std::string; -#line 3211 "reflect.h2" +#line 3353 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; -#line 3231 "reflect.h2" +#line 3384 "reflect.h2" public: auto add_groups(std::set& groups) const -> void override; public: virtual ~group_token() noexcept; @@ -1313,69 +1376,73 @@ class group_token public: auto operator=(group_token const&) -> void = delete; -#line 3238 "reflect.h2" +#line 3391 "reflect.h2" }; -#line 3241 "reflect.h2" +#line 3394 "reflect.h2" // Regex syntax: \x or \x{} Example: \x{62} // [[nodiscard]] auto hexadecimal_token_parse(parse_context& ctx) -> token_ptr; -#line 3282 "reflect.h2" +#line 3435 "reflect.h2" // Regex syntax: $ Example: aa$ // [[nodiscard]] auto line_end_token_parse(parse_context& ctx) -> token_ptr; -#line 3302 "reflect.h2" +#line 3455 "reflect.h2" // Regex syntax: ^ Example: ^aa // [[nodiscard]] auto line_start_token_parse(parse_context& ctx) -> token_ptr; -#line 3318 "reflect.h2" +#line 3471 "reflect.h2" // Regex syntax: (?=) or (?!) or (*pla), etc. Example: (?=AA) // // Parsed in group_token. // -class lookahead_token +class lookahead_lookbehind_token : public regex_token { -#line 3326 "reflect.h2" +#line 3479 "reflect.h2" + protected: bool lookahead; protected: bool positive; public: token_ptr inner {nullptr}; - public: lookahead_token(cpp2::impl::in positive_); + public: lookahead_lookbehind_token(cpp2::impl::in lookahead_, cpp2::impl::in positive_); -#line 3333 "reflect.h2" +#line 3488 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; -#line 3339 "reflect.h2" +#line 3499 "reflect.h2" + public: [[nodiscard]] auto reverse() const -> token_ptr override; + +#line 3506 "reflect.h2" public: auto add_groups(std::set& groups) const -> void override; - public: virtual ~lookahead_token() noexcept; + public: virtual ~lookahead_lookbehind_token() noexcept; - public: lookahead_token(lookahead_token const&) = delete; /* No 'that' constructor, suppress copy */ - public: auto operator=(lookahead_token const&) -> void = delete; + public: lookahead_lookbehind_token(lookahead_lookbehind_token const&) = delete; /* No 'that' constructor, suppress copy */ + public: auto operator=(lookahead_lookbehind_token const&) -> void = delete; -#line 3342 "reflect.h2" +#line 3509 "reflect.h2" }; -#line 3345 "reflect.h2" +#line 3512 "reflect.h2" // Named character classes // [[nodiscard]] auto named_class_token_parse(parse_context& ctx) -> token_ptr; -#line 3373 "reflect.h2" +#line 3540 "reflect.h2" // Regex syntax: \o{} Example: \o{142} // [[nodiscard]] auto octal_token_parse(parse_context& ctx) -> token_ptr; -#line 3401 "reflect.h2" +#line 3568 "reflect.h2" // Regex syntax: {min, max} Example: a{2,4} // class range_token : public regex_token { -#line 3407 "reflect.h2" +#line 3574 "reflect.h2" protected: int min_count {-1}; protected: int max_count {-1}; protected: int kind {range_flags::greedy}; @@ -1385,19 +1452,22 @@ class range_token public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr; -#line 3487 "reflect.h2" +#line 3654 "reflect.h2" public: auto parse_modifier(parse_context& ctx) & -> void; -#line 3499 "reflect.h2" +#line 3666 "reflect.h2" public: [[nodiscard]] auto gen_mod_string() const& -> std::string; -#line 3512 "reflect.h2" +#line 3679 "reflect.h2" public: [[nodiscard]] auto gen_range_string() const& -> std::string; -#line 3531 "reflect.h2" +#line 3698 "reflect.h2" + public: [[nodiscard]] auto reverse() const -> token_ptr override; + +#line 3708 "reflect.h2" public: auto generate_code(generation_context& ctx) const -> void override; -#line 3542 "reflect.h2" +#line 3719 "reflect.h2" public: auto add_groups(std::set& groups) const -> void override; public: virtual ~range_token() noexcept; @@ -1405,16 +1475,16 @@ class range_token public: auto operator=(range_token const&) -> void = delete; -#line 3546 "reflect.h2" +#line 3722 "reflect.h2" }; -#line 3549 "reflect.h2" +#line 3725 "reflect.h2" // Regex syntax: *, +, or ? Example: aa* // class special_range_token : public range_token { -#line 3555 "reflect.h2" +#line 3731 "reflect.h2" public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr; public: virtual ~special_range_token() noexcept; @@ -1423,17 +1493,23 @@ class special_range_token public: auto operator=(special_range_token const&) -> void = delete; -#line 3585 "reflect.h2" +#line 3761 "reflect.h2" }; -#line 3588 "reflect.h2" +// Regex syntax: \G Example: \Gaa +// +// Forces the match and/or consecutive matches to start at the position of the last match. +// +[[nodiscard]] auto start_match_parse(parse_context& ctx) -> token_ptr; + +#line 3783 "reflect.h2" // Regex syntax: \b or \B Example: \bword\b // // Matches the start end end of word boundaries. // [[nodiscard]] auto word_boundary_token_parse(parse_context& ctx) -> token_ptr; -#line 3610 "reflect.h2" +#line 3805 "reflect.h2" //----------------------------------------------------------------------- // // Parser for regular expression. @@ -1454,24 +1530,24 @@ template class regex_generator public: regex_generator(cpp2::impl::in r, Error_out const& e); -#line 3633 "reflect.h2" +#line 3828 "reflect.h2" public: [[nodiscard]] auto parse() & -> std::string; -#line 3668 "reflect.h2" +#line 3863 "reflect.h2" private: auto extract_modifiers() & -> void; public: regex_generator(regex_generator const&) = delete; /* No 'that' constructor, suppress copy */ public: auto operator=(regex_generator const&) -> void = delete; -#line 3682 "reflect.h2" +#line 3877 "reflect.h2" }; template [[nodiscard]] auto generate_regex(cpp2::impl::in regex, Err const& err) -> std::string; -#line 3694 "reflect.h2" +#line 3889 "reflect.h2" auto regex_gen(meta::type_declaration& t) -> void; -#line 3749 "reflect.h2" +#line 3944 "reflect.h2" //----------------------------------------------------------------------- // // apply_metafunctions @@ -1482,7 +1558,7 @@ auto regex_gen(meta::type_declaration& t) -> void; auto const& error ) -> bool; -#line 3866 "reflect.h2" +#line 4061 "reflect.h2" } } @@ -3470,83 +3546,93 @@ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::mov //parse: (inout ctx: parse_context) -> token_ptr; // Generate the matching code. + // Create a reverse token for look behind expressions. -#line 1679 "reflect.h2" - auto regex_token::add_groups([[maybe_unused]] std::set& unnamed_param_2) const -> void{}// Adds all group indices to the set. #line 1680 "reflect.h2" - [[nodiscard]] auto regex_token::to_string() const& -> std::string{return string_rep; }// Create a string representation. + auto regex_token::add_groups([[maybe_unused]] std::set& unnamed_param_2) const -> void{}// Adds all group indices to the set. #line 1681 "reflect.h2" + [[nodiscard]] auto regex_token::to_string() const& -> std::string{return string_rep; }// Create a string representation. +#line 1682 "reflect.h2" auto regex_token::set_string(cpp2::impl::in s) & -> void{string_rep = s; } regex_token::~regex_token() noexcept{}// Set the string representation. -#line 1696 "reflect.h2" +#line 1697 "reflect.h2" regex_token_check::regex_token_check(cpp2::impl::in str, cpp2::impl::in check_) : regex_token{ str } , check{ check_ }{ -#line 1699 "reflect.h2" +#line 1700 "reflect.h2" } -#line 1701 "reflect.h2" +#line 1702 "reflect.h2" auto regex_token_check::generate_code(generation_context& ctx) const -> void{ ctx.add_check(check + "(" + ctx.match_parameters() + ")"); } +#line 1706 "reflect.h2" + [[nodiscard]] auto regex_token_check::reverse() const -> token_ptr { return CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, CPP2_UFCS(to_string)((*this)), (*this).check); } + regex_token_check::~regex_token_check() noexcept{} -#line 1715 "reflect.h2" +#line 1718 "reflect.h2" regex_token_code::regex_token_code(cpp2::impl::in str, cpp2::impl::in code_) : regex_token{ str } , code{ code_ }{ -#line 1718 "reflect.h2" +#line 1721 "reflect.h2" } -#line 1720 "reflect.h2" +#line 1723 "reflect.h2" auto regex_token_code::generate_code(generation_context& ctx) const -> void{ ctx.add(code); } +#line 1727 "reflect.h2" + [[nodiscard]] auto regex_token_code::reverse() const -> token_ptr { return CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, CPP2_UFCS(to_string)((*this)), (*this).code); } + regex_token_code::~regex_token_code() noexcept{} -#line 1732 "reflect.h2" +#line 1737 "reflect.h2" regex_token_empty::regex_token_empty(cpp2::impl::in str) : regex_token{ str }{ -#line 1734 "reflect.h2" +#line 1739 "reflect.h2" } -#line 1736 "reflect.h2" +#line 1741 "reflect.h2" auto regex_token_empty::generate_code([[maybe_unused]] generation_context& unnamed_param_2) const -> void{ // Nothing. } +#line 1745 "reflect.h2" + [[nodiscard]] auto regex_token_empty::reverse() const -> token_ptr { return CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, CPP2_UFCS(to_string)((*this))); } + regex_token_empty::~regex_token_empty() noexcept{} -#line 1750 "reflect.h2" +#line 1757 "reflect.h2" regex_token_list::regex_token_list(cpp2::impl::in t) : regex_token{ gen_string(t) } , tokens{ t }{ -#line 1753 "reflect.h2" +#line 1760 "reflect.h2" } -#line 1755 "reflect.h2" +#line 1762 "reflect.h2" auto regex_token_list::generate_code(generation_context& ctx) const -> void{ for ( auto const& token : tokens ) { (*cpp2::impl::assert_not_null(token)).generate_code(ctx); } } -#line 1761 "reflect.h2" +#line 1768 "reflect.h2" auto regex_token_list::add_groups(std::set& groups) const -> void{ for ( auto const& token : tokens ) { (*cpp2::impl::assert_not_null(token)).add_groups(groups); } } -#line 1767 "reflect.h2" +#line 1774 "reflect.h2" [[nodiscard]] auto regex_token_list::gen_string(cpp2::impl::in vec) -> std::string{ std::string r {""}; for ( auto const& token : vec ) { @@ -3555,9 +3641,23 @@ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::mov return r; } +#line 1782 "reflect.h2" + [[nodiscard]] auto regex_token_list::reverse() const -> token_ptr{ + int s {cpp2::unchecked_narrow(tokens.size())}; + + token_vec reverse_vec {}; + reverse_vec.resize(s); + + int i {0}; + for( ; cpp2::impl::cmp_less(i,CPP2_UFCS(ssize)(tokens)); (i += 1) ) { + CPP2_ASSERT_IN_BOUNDS(reverse_vec, s - 1 - i) = CPP2_UFCS(reverse)((*cpp2::impl::assert_not_null(CPP2_ASSERT_IN_BOUNDS(tokens, i)))); + } + return CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, cpp2::move(reverse_vec)); + } + regex_token_list::~regex_token_list() noexcept{} -#line 1790 "reflect.h2" +#line 1810 "reflect.h2" auto parse_context_group_state::next_alternative() & -> void{ token_vec new_list {}; std::swap(new_list, cur_match_list); @@ -3565,14 +3665,14 @@ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::mov static_cast(alternate_match_lists.insert(alternate_match_lists.end(), CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, cpp2::move(new_list)))); } -#line 1798 "reflect.h2" +#line 1818 "reflect.h2" auto parse_context_group_state::swap(parse_context_group_state& t) & -> void{// NOLINT(performance-noexcept-swap) std::swap(cur_match_list, t.cur_match_list); std::swap(alternate_match_lists, t.alternate_match_lists); std::swap(modifiers, t.modifiers); } -#line 1805 "reflect.h2" +#line 1825 "reflect.h2" [[nodiscard]] auto parse_context_group_state::get_as_token() & -> token_ptr{ if (alternate_match_lists.empty()) { post_process_list(cur_match_list); @@ -3584,15 +3684,15 @@ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::mov } } -#line 1817 "reflect.h2" +#line 1837 "reflect.h2" auto parse_context_group_state::add(cpp2::impl::in token) & -> void{ cur_match_list.push_back(token); } -#line 1822 "reflect.h2" +#line 1842 "reflect.h2" [[nodiscard]] auto parse_context_group_state::empty() const& -> bool { return cur_match_list.empty(); } -#line 1826 "reflect.h2" +#line 1846 "reflect.h2" auto parse_context_group_state::post_process_list(token_vec& list) -> void{ // Merge all characters auto merge_pos {list.begin()}; @@ -3613,7 +3713,7 @@ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::mov , modifiers{ modifiers_ }{} parse_context_group_state::parse_context_group_state(){} -#line 1852 "reflect.h2" +#line 1872 "reflect.h2" [[nodiscard]] auto parse_context_branch_reset_state::next() & -> int{ auto g {cur_group}; cur_group += 1; @@ -3622,20 +3722,20 @@ parse_context_group_state::parse_context_group_state(){} return g; } -#line 1861 "reflect.h2" +#line 1881 "reflect.h2" auto parse_context_branch_reset_state::set_next(cpp2::impl::in g) & -> void{ cur_group = g; max_group = max(max_group, g); } -#line 1867 "reflect.h2" +#line 1887 "reflect.h2" auto parse_context_branch_reset_state::next_alternative() & -> void{ if (is_active) { cur_group = from; } } -#line 1874 "reflect.h2" +#line 1894 "reflect.h2" auto parse_context_branch_reset_state::set_active_reset(cpp2::impl::in restart) & -> void{ is_active = true; cur_group = restart; @@ -3650,16 +3750,16 @@ parse_context_group_state::parse_context_group_state(){} , from{ from_ }{} parse_context_branch_reset_state::parse_context_branch_reset_state(){} -#line 1902 "reflect.h2" +#line 1924 "reflect.h2" parse_context::parse_context(cpp2::impl::in r, auto const& e) : regex{ r } , root{ CPP2_UFCS_TEMPLATE_NONLOCAL(cpp2_new)(cpp2::shared, "") } , error_out{ e }{ -#line 1906 "reflect.h2" +#line 1928 "reflect.h2" } -#line 1912 "reflect.h2" +#line 1934 "reflect.h2" [[nodiscard]] auto parse_context::start_group() & -> parse_context_group_state { parse_context_group_state old_state {}; @@ -3669,7 +3769,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return old_state; } -#line 1922 "reflect.h2" +#line 1944 "reflect.h2" [[nodiscard]] auto parse_context::end_group(cpp2::impl::in old_state) & -> token_ptr { auto inner {cur_group_state.get_as_token()}; @@ -3677,17 +3777,17 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return inner; } -#line 1929 "reflect.h2" +#line 1951 "reflect.h2" [[nodiscard]] auto parse_context::get_modifiers() const& -> expression_flags{ return cur_group_state.modifiers; } -#line 1933 "reflect.h2" +#line 1955 "reflect.h2" auto parse_context::set_modifiers(cpp2::impl::in mod) & -> void{ cur_group_state.modifiers = mod; } -#line 1940 "reflect.h2" +#line 1962 "reflect.h2" [[nodiscard]] auto parse_context::branch_reset_new_state() & -> parse_context_branch_reset_state { parse_context_branch_reset_state old_state {}; @@ -3697,7 +3797,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return old_state; } -#line 1949 "reflect.h2" +#line 1971 "reflect.h2" auto parse_context::branch_reset_restore_state(cpp2::impl::in old_state) & -> void { auto max_group {cur_branch_reset_state.max_group}; @@ -3705,24 +3805,24 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} cur_branch_reset_state.set_next(cpp2::move(max_group)); } -#line 1956 "reflect.h2" +#line 1978 "reflect.h2" auto parse_context::next_alternative() & -> void { cur_group_state.next_alternative(); cur_branch_reset_state.next_alternative(); } -#line 1964 "reflect.h2" +#line 1986 "reflect.h2" auto parse_context::add_token(cpp2::impl::in token) & -> void{ cur_group_state.add(token); } -#line 1968 "reflect.h2" +#line 1990 "reflect.h2" [[nodiscard]] auto parse_context::has_token() const& -> bool{ return !(cur_group_state.empty()); } -#line 1972 "reflect.h2" +#line 1994 "reflect.h2" [[nodiscard]] auto parse_context::pop_token() & -> token_ptr { token_ptr r {nullptr}; @@ -3734,22 +3834,22 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return r; } -#line 1983 "reflect.h2" +#line 2005 "reflect.h2" [[nodiscard]] auto parse_context::get_as_token() & -> token_ptr{ return root; } -#line 1989 "reflect.h2" +#line 2011 "reflect.h2" [[nodiscard]] auto parse_context::get_cur_group() const& -> int{ return cur_branch_reset_state.cur_group; } -#line 1993 "reflect.h2" +#line 2015 "reflect.h2" [[nodiscard]] auto parse_context::next_group() & -> int{ return cur_branch_reset_state.next(); } -#line 1997 "reflect.h2" +#line 2019 "reflect.h2" auto parse_context::set_named_group(cpp2::impl::in name, cpp2::impl::in id) & -> void { if (!(named_groups.contains(name))) {// Redefinition of group name is not an error. The left most one is retained. @@ -3757,7 +3857,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} } } -#line 2004 "reflect.h2" +#line 2026 "reflect.h2" [[nodiscard]] auto parse_context::get_named_group(cpp2::impl::in name) const& -> int { auto iter {named_groups.find(name)}; @@ -3769,10 +3869,10 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} } } -#line 2017 "reflect.h2" +#line 2039 "reflect.h2" [[nodiscard]] auto parse_context::current() const& -> char{return CPP2_ASSERT_IN_BOUNDS(regex, pos); } -#line 2020 "reflect.h2" +#line 2042 "reflect.h2" [[nodiscard]] auto parse_context::get_next_position(cpp2::impl::in in_class, cpp2::impl::in no_skip) const& -> size_t { auto perl_syntax {false}; @@ -3812,7 +3912,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return cur; } -#line 2060 "reflect.h2" +#line 2082 "reflect.h2" [[nodiscard]] auto parse_context::next_impl(cpp2::impl::in in_class, cpp2::impl::in no_skip) & -> bool { pos = get_next_position(in_class, no_skip); @@ -3824,14 +3924,14 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} } } -#line 2071 "reflect.h2" +#line 2093 "reflect.h2" [[nodiscard]] auto parse_context::next() & -> decltype(auto) { return next_impl(false, false); } -#line 2072 "reflect.h2" +#line 2094 "reflect.h2" [[nodiscard]] auto parse_context::next_in_class() & -> decltype(auto) { return next_impl(true, false); } -#line 2073 "reflect.h2" +#line 2095 "reflect.h2" [[nodiscard]] auto parse_context::next_no_skip() & -> decltype(auto) { return next_impl(false, true); } -#line 2075 "reflect.h2" +#line 2097 "reflect.h2" [[nodiscard]] auto parse_context::next_n(cpp2::impl::in n) & -> bool{ auto r {true}; auto cur {0}; @@ -3841,10 +3941,10 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return r; } -#line 2084 "reflect.h2" +#line 2106 "reflect.h2" [[nodiscard]] auto parse_context::has_next() const& -> bool{return cpp2::impl::cmp_less(pos,regex.size()); } -#line 2086 "reflect.h2" +#line 2108 "reflect.h2" [[nodiscard]] auto parse_context::grab_until_impl(cpp2::impl::in e, cpp2::impl::out r, cpp2::impl::in any) & -> bool { auto end {pos}; // NOLINT(clang-analyzer-deadcode.DeadStores) @@ -3866,14 +3966,14 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} } } -#line 2107 "reflect.h2" +#line 2129 "reflect.h2" [[nodiscard]] auto parse_context::grab_until(cpp2::impl::in e, cpp2::impl::out r) & -> decltype(auto) { return grab_until_impl(e, cpp2::impl::out(&r), false); } -#line 2108 "reflect.h2" +#line 2130 "reflect.h2" [[nodiscard]] auto parse_context::grab_until(cpp2::impl::in e, cpp2::impl::out r) & -> decltype(auto) { return grab_until_impl(std::string(1, e), cpp2::impl::out(&r), false); } -#line 2109 "reflect.h2" +#line 2131 "reflect.h2" [[nodiscard]] auto parse_context::grab_until_one_of(cpp2::impl::in e, cpp2::impl::out r) & -> decltype(auto) { return grab_until_impl(e, cpp2::impl::out(&r), true); } -#line 2111 "reflect.h2" +#line 2133 "reflect.h2" [[nodiscard]] auto parse_context::grab_n(cpp2::impl::in n, cpp2::impl::out r) & -> bool { if (cpp2::impl::cmp_less_eq(pos + cpp2::impl::as_(n),regex.size())) { @@ -3887,7 +3987,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} } } -#line 2124 "reflect.h2" +#line 2146 "reflect.h2" [[nodiscard]] auto parse_context::grab_number() & -> std::string { auto start {pos}; @@ -3909,7 +4009,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return cpp2::move(r.value()); } -#line 2145 "reflect.h2" +#line 2167 "reflect.h2" [[nodiscard]] auto parse_context::peek_impl(cpp2::impl::in in_class) const& -> char{ auto next_pos {get_next_position(in_class, false)}; if (cpp2::impl::cmp_less(next_pos,regex.size())) { @@ -3920,12 +4020,12 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} } } -#line 2155 "reflect.h2" +#line 2177 "reflect.h2" [[nodiscard]] auto parse_context::peek() const& -> decltype(auto) { return peek_impl(false); } -#line 2156 "reflect.h2" +#line 2178 "reflect.h2" [[nodiscard]] auto parse_context::peek_in_class() const& -> decltype(auto) { return peek_impl(true); } -#line 2161 "reflect.h2" +#line 2183 "reflect.h2" [[nodiscard]] auto parse_context::parser_group_modifiers(cpp2::impl::in change_str, expression_flags& parser_modifiers) & -> bool { auto is_negative {false}; @@ -3980,7 +4080,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return true; } -#line 2215 "reflect.h2" +#line 2237 "reflect.h2" [[nodiscard]] auto parse_context::parse_until(cpp2::impl::in term) & -> bool{ token_ptr cur_token {}; @@ -4004,6 +4104,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} if (!(cur_token) && valid()) {cur_token = octal_token_parse((*this)); } if (!(cur_token) && valid()) {cur_token = range_token::parse((*this)); } if (!(cur_token) && valid()) {cur_token = special_range_token::parse((*this)); } + if (!(cur_token) && valid()) {cur_token = start_match_parse((*this)); } if (!(cur_token) && valid()) {cur_token = word_boundary_token_parse((*this)); } // Everything else is matched as it is. @@ -4019,7 +4120,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return true; } -#line 2253 "reflect.h2" +#line 2276 "reflect.h2" [[nodiscard]] auto parse_context::parse(cpp2::impl::in modifiers) & -> bool { @@ -4035,21 +4136,21 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} return r; } -#line 2270 "reflect.h2" +#line 2293 "reflect.h2" [[nodiscard]] auto parse_context::get_pos() const& -> decltype(auto) { return pos; } -#line 2271 "reflect.h2" +#line 2294 "reflect.h2" [[nodiscard]] auto parse_context::get_range(cpp2::impl::in start, cpp2::impl::in end) const& -> decltype(auto) { return std::string(regex.substr(start, end - start + 1)); } -#line 2272 "reflect.h2" +#line 2295 "reflect.h2" [[nodiscard]] auto parse_context::valid() const& -> bool{return has_next() && !(has_error); } -#line 2274 "reflect.h2" +#line 2297 "reflect.h2" [[nodiscard]] auto parse_context::error(cpp2::impl::in err) & -> token_ptr{ has_error = true; error_out("Error during parsing of regex '" + cpp2::to_string(regex) + "' at position '" + cpp2::to_string(pos) + "': " + cpp2::to_string(err) + ""); return nullptr; } -#line 2289 "reflect.h2" +#line 2312 "reflect.h2" auto generation_function_context::add_tabs(cpp2::impl::in c) & -> void{ int i {0}; for( ; cpp2::impl::cmp_less(i,c); i += 1 ) { @@ -4057,7 +4158,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} } } -#line 2296 "reflect.h2" +#line 2319 "reflect.h2" auto generation_function_context::remove_tabs(cpp2::impl::in c) & -> void{ tabs = tabs.substr(0, (cpp2::impl::as_(c)) * 2); } @@ -4067,22 +4168,22 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){} , tabs{ tabs_ }{} generation_function_context::generation_function_context(){} -#line 2314 "reflect.h2" +#line 2337 "reflect.h2" [[nodiscard]] auto generation_context::match_parameters() const& -> std::string{return "r.pos, ctx"; } -#line 2319 "reflect.h2" +#line 2342 "reflect.h2" auto generation_context::add(cpp2::impl::in s) & -> void{ auto cur {get_current()}; (*cpp2::impl::assert_not_null(cur)).code += "" + cpp2::to_string((*cpp2::impl::assert_not_null(cur)).tabs) + cpp2::to_string(s) + "\n"; } -#line 2325 "reflect.h2" +#line 2348 "reflect.h2" auto generation_context::add_check(cpp2::impl::in check) & -> void{ auto cur {get_current()}; (*cpp2::impl::assert_not_null(cur)).code += "" + cpp2::to_string((*cpp2::impl::assert_not_null(cur)).tabs) + "if !cpp2::regex::" + cpp2::to_string(check) + " { r.matched = false; break; }\n"; } -#line 2331 "reflect.h2" +#line 2354 "reflect.h2" auto generation_context::add_statefull(cpp2::impl::in next_func, cpp2::impl::in check) & -> void { end_func_statefull(check); @@ -4091,19 +4192,19 @@ generation_function_context::generation_function_context(){} start_func_named(cpp2::move(name)); } -#line 2339 "reflect.h2" +#line 2362 "reflect.h2" auto generation_context::start_func_named(cpp2::impl::in name) & -> void { auto cur {new_context()}; (*cpp2::impl::assert_not_null(cur)).code += "" + cpp2::to_string((*cpp2::impl::assert_not_null(cur)).tabs) + cpp2::to_string(name) + ": @struct type = {\n"; - (*cpp2::impl::assert_not_null(cur)).code += "" + cpp2::to_string((*cpp2::impl::assert_not_null(cur)).tabs) + " operator(): (this, cur: Iter, inout ctx: context, other) -> cpp2::regex::match_return = {\n"; + (*cpp2::impl::assert_not_null(cur)).code += "" + cpp2::to_string((*cpp2::impl::assert_not_null(cur)).tabs) + " operator(): (this, cur: Iter, forward ctx, other) -> cpp2::regex::match_return = {\n"; (*cpp2::impl::assert_not_null(cur)).code += "" + cpp2::to_string((*cpp2::impl::assert_not_null(cur)).tabs) + " r := ctx..pass(cur);\n"; (*cpp2::impl::assert_not_null(cur)).code += "" + cpp2::to_string((*cpp2::impl::assert_not_null(cur)).tabs) + " do {\n"; (*cpp2::impl::assert_not_null(cpp2::move(cur))).add_tabs(3); } -#line 2350 "reflect.h2" +#line 2373 "reflect.h2" [[nodiscard]] auto generation_context::start_func() & -> std::string { auto name {gen_func_name()}; @@ -4111,7 +4212,7 @@ generation_function_context::generation_function_context(){} return cpp2::move(name) + "()"; } -#line 2357 "reflect.h2" +#line 2380 "reflect.h2" auto generation_context::end_func_statefull(cpp2::impl::in s) & -> void { auto cur {get_current()}; @@ -4124,6 +4225,7 @@ generation_function_context::generation_function_context(){} (*cpp2::impl::assert_not_null(cur)).code += "" + cpp2::to_string((*cpp2::impl::assert_not_null(cur)).tabs) + " else {\n"; (*cpp2::impl::assert_not_null(cur)).code += "" + cpp2::to_string((*cpp2::impl::assert_not_null(cur)).tabs) + " r.pos = ctx.end;\n"; (*cpp2::impl::assert_not_null(cur)).code += "" + cpp2::to_string((*cpp2::impl::assert_not_null(cur)).tabs) + " }\n"; + (*cpp2::impl::assert_not_null(cur)).code += "" + cpp2::to_string((*cpp2::impl::assert_not_null(cur)).tabs) + " _ = ctx;\n"; (*cpp2::impl::assert_not_null(cur)).code += "" + cpp2::to_string((*cpp2::impl::assert_not_null(cur)).tabs) + " return r;\n"; (*cpp2::impl::assert_not_null(cur)).code += "" + cpp2::to_string((*cpp2::impl::assert_not_null(cur)).tabs) + " }\n"; (*cpp2::impl::assert_not_null(cur)).code += "" + cpp2::to_string((*cpp2::impl::assert_not_null(cur)).tabs) + "}\n"; @@ -4131,7 +4233,7 @@ generation_function_context::generation_function_context(){} finish_context(); } -#line 2377 "reflect.h2" +#line 2401 "reflect.h2" [[nodiscard]] auto generation_context::generate_func(cpp2::impl::in token) & -> std::string { auto name {start_func()}; @@ -4141,7 +4243,7 @@ generation_function_context::generation_function_context(){} return name; } -#line 2387 "reflect.h2" +#line 2411 "reflect.h2" [[nodiscard]] auto generation_context::generate_reset(cpp2::impl::in> groups) & -> std::string { if (groups.empty()) { @@ -4164,33 +4266,33 @@ generation_function_context::generation_function_context(){} return cpp2::move(name) + "()"; } -#line 2411 "reflect.h2" +#line 2435 "reflect.h2" [[nodiscard]] auto generation_context::gen_func_name() & -> std::string{ auto cur_id {matcher_func}; matcher_func += 1; return "func_" + cpp2::to_string(cpp2::move(cur_id)) + ""; } -#line 2417 "reflect.h2" +#line 2441 "reflect.h2" [[nodiscard]] auto generation_context::next_func_name() & -> std::string{ return gen_func_name() + "()"; } -#line 2421 "reflect.h2" +#line 2445 "reflect.h2" [[nodiscard]] auto generation_context::gen_reset_func_name() & -> std::string{ auto cur_id {reset_func}; reset_func += 1; return "reset_" + cpp2::to_string(cpp2::move(cur_id)) + ""; } -#line 2427 "reflect.h2" +#line 2451 "reflect.h2" [[nodiscard]] auto generation_context::gen_temp() & -> std::string{ auto cur_id {temp_name}; temp_name += 1; return "tmp_" + cpp2::to_string(cpp2::move(cur_id)) + ""; } -#line 2435 "reflect.h2" +#line 2459 "reflect.h2" [[nodiscard]] auto generation_context::new_context() & -> generation_function_context*{ gen_stack.push_back(generation_function_context()); auto cur {get_current()}; @@ -4199,7 +4301,7 @@ generation_function_context::generation_function_context(){} return cur; } -#line 2443 "reflect.h2" +#line 2467 "reflect.h2" auto generation_context::finish_context() & -> void{ auto cur {get_current()}; auto base {get_base()}; @@ -4208,22 +4310,22 @@ generation_function_context::generation_function_context(){} gen_stack.pop_back(); } -#line 2453 "reflect.h2" +#line 2477 "reflect.h2" [[nodiscard]] auto generation_context::get_current() & -> generation_function_context*{ return &gen_stack.back(); } -#line 2457 "reflect.h2" +#line 2481 "reflect.h2" [[nodiscard]] auto generation_context::get_base() & -> generation_function_context*{ return &CPP2_ASSERT_IN_BOUNDS_LITERAL(gen_stack, 0); } -#line 2461 "reflect.h2" +#line 2485 "reflect.h2" [[nodiscard]] auto generation_context::get_entry_func() const& -> std::string{ return entry_func; } -#line 2465 "reflect.h2" +#line 2489 "reflect.h2" [[nodiscard]] auto generation_context::create_named_group_lookup(cpp2::impl::in> named_groups) const& -> std::string { std::string res {"get_named_group_index: (name) -> int = {\n"}; @@ -4247,18 +4349,18 @@ generation_function_context::generation_function_context(){} return res; } -#line 2490 "reflect.h2" +#line 2514 "reflect.h2" [[nodiscard]] auto generation_context::run(cpp2::impl::in token) & -> std::string{ entry_func = generate_func(token); return (*cpp2::impl::assert_not_null(get_base())).code; } -#line 2505 "reflect.h2" +#line 2529 "reflect.h2" alternative_token::alternative_token() : regex_token_empty{ "" }{} -#line 2507 "reflect.h2" +#line 2531 "reflect.h2" [[nodiscard]] auto alternative_token::parse(parse_context& ctx) -> token_ptr{ if (ctx.current() != '|') {return nullptr; } @@ -4269,15 +4371,15 @@ generation_function_context::generation_function_context(){} alternative_token::~alternative_token() noexcept{} -#line 2522 "reflect.h2" +#line 2546 "reflect.h2" alternative_token_gen::alternative_token_gen(cpp2::impl::in a) : regex_token{ gen_string(a) } , alternatives{ a }{ -#line 2525 "reflect.h2" +#line 2549 "reflect.h2" } -#line 2527 "reflect.h2" +#line 2551 "reflect.h2" auto alternative_token_gen::generate_code(generation_context& ctx) const -> void { std::string functions {""}; @@ -4295,7 +4397,7 @@ generation_function_context::generation_function_context(){} ctx.add_statefull(next_name, "cpp2::regex::alternative_token_matcher::match(" + cpp2::to_string(ctx.match_parameters()) + ", other, " + cpp2::to_string(next_name) + " " + cpp2::to_string(cpp2::move(functions)) + ")"); } -#line 2544 "reflect.h2" +#line 2568 "reflect.h2" auto alternative_token_gen::add_groups(std::set& groups) const -> void { for ( auto const& cur : alternatives ) { @@ -4303,7 +4405,7 @@ generation_function_context::generation_function_context(){} } } -#line 2551 "reflect.h2" +#line 2575 "reflect.h2" [[nodiscard]] auto alternative_token_gen::gen_string(cpp2::impl::in a) -> std::string { std::string r {""}; @@ -4317,16 +4419,30 @@ generation_function_context::generation_function_context(){} return r; } +#line 2588 "reflect.h2" + [[nodiscard]] auto alternative_token_gen::reverse() const -> token_ptr{ + int s {cpp2::unchecked_narrow(alternatives.size())}; + + token_vec reverse_vec {}; + reverse_vec.resize(s); + + int i {0}; + for( ; cpp2::impl::cmp_less(i,s); (i += 1) ) { + CPP2_ASSERT_IN_BOUNDS(reverse_vec, i) = CPP2_UFCS(reverse)((*cpp2::impl::assert_not_null(CPP2_ASSERT_IN_BOUNDS(alternatives, i))));// We only reverse the alternatives, not the order in which they are checked. + } + return CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, cpp2::move(reverse_vec)); + } + alternative_token_gen::~alternative_token_gen() noexcept{} -#line 2572 "reflect.h2" +#line 2609 "reflect.h2" any_token::any_token(cpp2::impl::in single_line) : regex_token_check{ ".", "any_token_matcher" }{ -#line 2574 "reflect.h2" +#line 2611 "reflect.h2" } -#line 2576 "reflect.h2" +#line 2613 "reflect.h2" [[nodiscard]] auto any_token::parse(parse_context& ctx) -> token_ptr{ if ('.' != ctx.current()) {return nullptr; } @@ -4335,21 +4451,58 @@ generation_function_context::generation_function_context(){} any_token::~any_token() noexcept{} -#line 2593 "reflect.h2" +#line 2628 "reflect.h2" + atomic_group_token::atomic_group_token() + : regex_token{ "" }{} + +#line 2630 "reflect.h2" + [[nodiscard]] auto atomic_group_token::reverse() const -> token_ptr{ + auto r {CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared)}; + (*cpp2::impl::assert_not_null(r)).inner_token = CPP2_UFCS(reverse)((*cpp2::impl::assert_not_null(inner_token))); + + return r; + } + +#line 2637 "reflect.h2" + auto atomic_group_token::generate_code(generation_context& ctx) const -> void + { + auto inner_name {ctx.generate_func(inner_token)}; + + auto next_name {ctx.next_func_name()}; + ctx.add_statefull(next_name, "cpp2::regex::atomic_group_matcher(" + cpp2::to_string(ctx.match_parameters()) + ", " + cpp2::to_string(cpp2::move(inner_name)) + ", other, " + cpp2::to_string(next_name) + ")"); + } + +#line 2645 "reflect.h2" + auto atomic_group_token::add_groups(std::set& groups) const -> void{ + (*cpp2::impl::assert_not_null(inner_token)).add_groups(groups); + } + + atomic_group_token::~atomic_group_token() noexcept{} + +#line 2659 "reflect.h2" char_token::char_token(cpp2::impl::in t, cpp2::impl::in ignore_case_) : regex_token{ std::string(1, t) } , token{ t } , ignore_case{ ignore_case_ }{ -#line 2597 "reflect.h2" +#line 2663 "reflect.h2" } -#line 2599 "reflect.h2" +#line 2665 "reflect.h2" + char_token::char_token(cpp2::impl::in t, cpp2::impl::in ignore_case_) + : regex_token{ t } + , token{ t } + , ignore_case{ ignore_case_ }{ + +#line 2669 "reflect.h2" + } + +#line 2671 "reflect.h2" [[nodiscard]] auto char_token::parse(parse_context& ctx) -> token_ptr{ return CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, ctx.current(), ctx.get_modifiers().has(expression_flags::case_insensitive)); } -#line 2603 "reflect.h2" +#line 2675 "reflect.h2" auto char_token::generate_code(generation_context& ctx) const -> void { if (ignore_case) { @@ -4358,14 +4511,14 @@ generation_function_context::generation_function_context(){} { size_t i{0}; -#line 2609 "reflect.h2" +#line 2681 "reflect.h2" for( ; cpp2::impl::cmp_less(i,token.size()); i += 1 ) { CPP2_ASSERT_IN_BOUNDS(lower, i) = string_util::safe_tolower(CPP2_ASSERT_IN_BOUNDS(token, i)); CPP2_ASSERT_IN_BOUNDS(upper, i) = string_util::safe_toupper(CPP2_ASSERT_IN_BOUNDS(token, i)); } } -#line 2614 "reflect.h2" +#line 2686 "reflect.h2" if (upper != lower) { gen_case_insensitive(cpp2::move(lower), cpp2::move(upper), ctx); } @@ -4378,7 +4531,7 @@ size_t i{0}; } } -#line 2626 "reflect.h2" +#line 2698 "reflect.h2" auto char_token::gen_case_insensitive(cpp2::impl::in lower, cpp2::impl::in upper, generation_context& ctx) const& -> void { std::string name {"str_" + cpp2::to_string(ctx.gen_temp()) + ""}; @@ -4400,7 +4553,7 @@ size_t i{0}; ctx.add("else { break; }"); } -#line 2647 "reflect.h2" +#line 2719 "reflect.h2" auto char_token::gen_case_sensitive(generation_context& ctx) const& -> void { std::string name {"str_" + cpp2::to_string(ctx.gen_temp()) + ""}; @@ -4419,7 +4572,7 @@ size_t i{0}; ctx.add("else { break; }"); } -#line 2665 "reflect.h2" +#line 2737 "reflect.h2" [[nodiscard]] auto char_token::add_escapes(std::string str) const& -> std::string { str = string_util::replace_all(str, "\\", "\\\\"); @@ -4435,7 +4588,14 @@ size_t i{0}; return cpp2::move(str); } -#line 2680 "reflect.h2" +#line 2752 "reflect.h2" + [[nodiscard]] auto char_token::reverse() const -> token_ptr{ + std::string reverse_str {token}; + std::reverse(reverse_str.begin(), reverse_str.end()); + return CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, cpp2::move(reverse_str), ignore_case); + } + +#line 2758 "reflect.h2" auto char_token::append(char_token const& that) & -> void{ (*this).token += that.token; (*this).string_rep += that.string_rep; @@ -4443,19 +4603,19 @@ size_t i{0}; char_token::~char_token() noexcept{} -#line 2697 "reflect.h2" +#line 2775 "reflect.h2" class_token::class_token(cpp2::impl::in negate_, cpp2::impl::in case_insensitive_, cpp2::impl::in class_str_, cpp2::impl::in str) : regex_token{ str } , negate{ negate_ } , case_insensitive{ case_insensitive_ } , class_str{ class_str_ } -#line 2698 "reflect.h2" +#line 2776 "reflect.h2" { -#line 2703 "reflect.h2" +#line 2781 "reflect.h2" } -#line 2706 "reflect.h2" +#line 2784 "reflect.h2" [[nodiscard]] auto class_token::parse(parse_context& ctx) -> token_ptr { if (ctx.current() != '[') {return nullptr; } @@ -4581,13 +4741,23 @@ size_t i{0}; ); } -#line 2831 "reflect.h2" +#line 2909 "reflect.h2" + [[nodiscard]] auto class_token::reverse() const -> token_ptr{ + return CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, + negate, + case_insensitive, + class_str, + to_string() + ); + } + +#line 2918 "reflect.h2" auto class_token::generate_code(generation_context& ctx) const -> void { ctx.add_check("class_token_matcher::match(" + cpp2::to_string(ctx.match_parameters()) + ")"); } -#line 2836 "reflect.h2" +#line 2923 "reflect.h2" [[nodiscard]] auto class_token::create_matcher(cpp2::impl::in name, cpp2::impl::in template_arguments) -> std::string { auto sep {", "}; @@ -4598,12 +4768,12 @@ size_t i{0}; class_token::~class_token() noexcept{} -#line 2848 "reflect.h2" +#line 2935 "reflect.h2" [[nodiscard]] auto escape_token_parse(parse_context& ctx) -> token_ptr { if (ctx.current() != '\\') {return nullptr; } -#line 2853 "reflect.h2" +#line 2940 "reflect.h2" if (std::string::npos == std::string("afenrt^.[]()*{}?+|\\").find(ctx.peek())) { return nullptr; } @@ -4637,7 +4807,7 @@ size_t i{0}; } -#line 2889 "reflect.h2" +#line 2976 "reflect.h2" [[nodiscard]] auto global_group_reset_token_parse(parse_context& ctx) -> token_ptr { if (!((ctx.current() == '\\' && ctx.peek() == 'K'))) {return nullptr; } @@ -4646,18 +4816,19 @@ size_t i{0}; return CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, "\\K", "ctx..set_group_start(0, r.pos);"); } -#line 2911 "reflect.h2" - group_ref_token::group_ref_token(cpp2::impl::in id_, cpp2::impl::in case_insensitive_, cpp2::impl::in str) +#line 2999 "reflect.h2" + group_ref_token::group_ref_token(cpp2::impl::in id_, cpp2::impl::in case_insensitive_, cpp2::impl::in reverse_, cpp2::impl::in str) : regex_token{ str } , id{ id_ } , case_insensitive{ case_insensitive_ } -#line 2912 "reflect.h2" + , reverse_eval{ reverse_ } +#line 3000 "reflect.h2" { -#line 2916 "reflect.h2" +#line 3005 "reflect.h2" } -#line 2918 "reflect.h2" +#line 3007 "reflect.h2" [[nodiscard]] auto group_ref_token::parse(parse_context& ctx) -> token_ptr { if (ctx.current() != '\\') {return nullptr; } @@ -4756,32 +4927,56 @@ size_t i{0}; if (-1 == group_id) {return ctx.error("Group names does not exist. (Name is: " + cpp2::to_string(cpp2::move(group)) + ")"); } } - return CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, cpp2::move(group_id), ctx.get_modifiers().has(expression_flags::case_insensitive), cpp2::move(str)); + return CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, cpp2::move(group_id), ctx.get_modifiers().has(expression_flags::case_insensitive), false, cpp2::move(str)); } -#line 3019 "reflect.h2" +#line 3108 "reflect.h2" + [[nodiscard]] auto group_ref_token::reverse() const -> token_ptr{ + return CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, id, case_insensitive, !(reverse_eval), to_string()); + } + +#line 3112 "reflect.h2" auto group_ref_token::generate_code(generation_context& ctx) const -> void{ - ctx.add_check("group_ref_token_matcher(" + cpp2::to_string(ctx.match_parameters()) + ")"); + ctx.add_check("group_ref_token_matcher(" + cpp2::to_string(ctx.match_parameters()) + ")"); } group_ref_token::~group_ref_token() noexcept{} -#line 3042 "reflect.h2" - [[nodiscard]] auto group_token::parse_lookahead(parse_context& ctx, cpp2::impl::in syntax, cpp2::impl::in positive) -> token_ptr +#line 3136 "reflect.h2" + [[nodiscard]] auto group_token::parse_lookahead_lookbehind(parse_context& ctx, cpp2::impl::in syntax, cpp2::impl::in lookahead, cpp2::impl::in positive) -> token_ptr { static_cast(ctx.next());// Skip last token defining the syntax - auto r {CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, positive)}; + auto r {CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, lookahead, positive)}; auto old_state {ctx.start_group()}; - if (!(ctx.parse_until(')'))) {return ctx.error("Lookahead without a closing bracket."); } + if (!(ctx.parse_until(')'))) {return ctx.error("Group without a closing bracket."); } (*cpp2::impl::assert_not_null(r)).inner = ctx.end_group(cpp2::move(old_state)); (*cpp2::impl::assert_not_null(r)).set_string("(" + cpp2::to_string(syntax) + cpp2::to_string((*cpp2::impl::assert_not_null((*cpp2::impl::assert_not_null(r)).inner)).to_string()) + ")"); + if (!(lookahead)) { + (*cpp2::impl::assert_not_null(r)).inner = (*cpp2::impl::assert_not_null((*cpp2::impl::assert_not_null(r)).inner)).reverse(); + } + + return r; + } + +#line 3154 "reflect.h2" + [[nodiscard]] auto group_token::parse_atomic_pattern(parse_context& ctx, cpp2::impl::in syntax) -> token_ptr + { + static_cast(ctx.next());// Skip last token defining the syntax + + auto r {CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared)}; + + auto old_state {ctx.start_group()}; + if (!(ctx.parse_until(')'))) {return ctx.error("Group without a closing bracket."); } + (*cpp2::impl::assert_not_null(r)).inner_token = ctx.end_group(cpp2::move(old_state)); + (*cpp2::impl::assert_not_null(r)).set_string("(" + cpp2::to_string(syntax) + cpp2::to_string((*cpp2::impl::assert_not_null((*cpp2::impl::assert_not_null(r)).inner_token)).to_string()) + ")"); + return r; } -#line 3056 "reflect.h2" +#line 3168 "reflect.h2" [[nodiscard]] auto group_token::parse(parse_context& ctx) -> token_ptr { if (ctx.current() != '(') {return nullptr; } @@ -4801,7 +4996,14 @@ size_t i{0}; // Special group if (!(ctx.next_no_skip())) {return ctx.error("Missing character after group opening."); } - if (ctx.current() == '<' || ctx.current() == '\'') + if ( CPP2_UFCS(current)(ctx) == '<' && (CPP2_UFCS(peek)(ctx) == '=' || CPP2_UFCS(peek)(ctx) == '!')) + { + // Lookbehind + static_cast(CPP2_UFCS(next)(ctx));// Skip the '<' + + return parse_lookahead_lookbehind(ctx, "?<" + cpp2::to_string(ctx.current()) + "", false, ctx.current() == '='); + } + else {if (ctx.current() == '<' || ctx.current() == '\'') { // Named group auto end_char {ctx.current()}; @@ -4852,7 +5054,13 @@ size_t i{0}; } else {if (ctx.current() == '=' || ctx.current() == '!') { - return parse_lookahead(ctx, "?" + cpp2::to_string(ctx.current()) + "", ctx.current() == '='); + // Lookahead + return parse_lookahead_lookbehind(ctx, "?" + cpp2::to_string(ctx.current()) + "", true, ctx.current() == '='); + } + else {if (ctx.current() == '>') + { + // Atomic pattern + return parse_atomic_pattern(ctx, "?" + cpp2::to_string(ctx.current()) + ""); } else { @@ -4869,7 +5077,7 @@ size_t i{0}; else { if (!(ctx.next())) { return ctx. error("Missing ending bracket for group."); }/* skip ':' */ } - }}}} + }}}}}} } else {if (ctx.current() == '*') { @@ -4879,14 +5087,23 @@ size_t i{0}; if (!(ctx.grab_until(':', cpp2::impl::out(&name)))) {return ctx.error("Missing colon for named pattern."); } if (name == "pla" || name == "positive_lookahead") { - return parse_lookahead(ctx, "*" + cpp2::to_string(cpp2::move(name)) + ":", true); + return parse_lookahead_lookbehind(ctx, "*" + cpp2::to_string(cpp2::move(name)) + ":", true, true); } else {if (name == "nla" || name == "negative_lookahead") { - return parse_lookahead(ctx, "*" + cpp2::to_string(cpp2::move(name)) + ":", false); + return parse_lookahead_lookbehind(ctx, "*" + cpp2::to_string(cpp2::move(name)) + ":", true, false); + } + else {if (name == "plb" || name == "positive_lookbehind") { + return parse_lookahead_lookbehind(ctx, "*" + cpp2::to_string(cpp2::move(name)) + ":", false, true); + } + else {if (name == "nlb" || name == "negative_lookbehind") { + return parse_lookahead_lookbehind(ctx, "*" + cpp2::to_string(cpp2::move(name)) + ":", false, false); + } + else {if (name == "atomic") { + return parse_atomic_pattern(ctx, "*" + cpp2::to_string(cpp2::move(name)) + ":"); } else { return ctx.error("Unknown named group pattern: '" + cpp2::to_string(cpp2::move(name)) + "'"); - }} + }}}}} }} if (cpp2::move(has_pattern)) @@ -4919,7 +5136,16 @@ size_t i{0}; } } -#line 3193 "reflect.h2" +#line 3327 "reflect.h2" + [[nodiscard]] auto group_token::reverse() const -> token_ptr{ + auto r {CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared)}; + (*cpp2::impl::assert_not_null(r)).number = number; + (*cpp2::impl::assert_not_null(r)).reverse_eval = !(reverse_eval); + (*cpp2::impl::assert_not_null(r)).inner = CPP2_UFCS(reverse)((*cpp2::impl::assert_not_null(inner))); + return r; + } + +#line 3335 "reflect.h2" [[nodiscard]] auto group_token::gen_string(cpp2::impl::in name, cpp2::impl::in name_brackets, cpp2::impl::in has_modifier, cpp2::impl::in modifiers, cpp2::impl::in inner_) -> std::string { std::string start {"("}; @@ -4938,16 +5164,27 @@ size_t i{0}; return cpp2::move(start) + (*cpp2::impl::assert_not_null(inner_)).to_string() + ")"; } -#line 3211 "reflect.h2" +#line 3353 "reflect.h2" auto group_token::generate_code(generation_context& ctx) const -> void { if (-1 != number) { - ctx.add("ctx..set_group_start(" + cpp2::to_string(number) + ", r.pos);"); + if (reverse_eval) { + ctx.add("ctx..set_group_end(" + cpp2::to_string(number) + ", r.pos);"); + } + else { + ctx.add("ctx..set_group_start(" + cpp2::to_string(number) + ", r.pos);"); + } } (*cpp2::impl::assert_not_null(inner)).generate_code(ctx); if (-1 != number) { - ctx.add("ctx..set_group_end(" + cpp2::to_string(number) + ", r.pos);"); + if (reverse_eval) { + ctx.add("ctx..set_group_start(" + cpp2::to_string(number) + ", r.pos);"); + } + else { + ctx.add("ctx..set_group_end(" + cpp2::to_string(number) + ", r.pos);"); + } + auto tmp_name {ctx.gen_temp()}; ctx.add("" + cpp2::to_string(tmp_name) + "_func := :() = {"); ctx.add(" if !r&$*.matched {"); @@ -4959,7 +5196,7 @@ size_t i{0}; } } -#line 3231 "reflect.h2" +#line 3384 "reflect.h2" auto group_token::add_groups(std::set& groups) const -> void { (*cpp2::impl::assert_not_null(inner)).add_groups(groups); @@ -4970,7 +5207,7 @@ size_t i{0}; group_token::~group_token() noexcept{} -#line 3243 "reflect.h2" +#line 3396 "reflect.h2" [[nodiscard]] auto hexadecimal_token_parse(parse_context& ctx) -> token_ptr { if (!((ctx.current() == '\\' && ctx.peek() == 'x'))) {return nullptr; } @@ -5009,7 +5246,7 @@ size_t i{0}; return r; } -#line 3284 "reflect.h2" +#line 3437 "reflect.h2" [[nodiscard]] auto line_end_token_parse(parse_context& ctx) -> token_ptr { if (ctx.current() == '$' || (ctx.current() == '\\' && ctx.peek() == '$')) { @@ -5027,7 +5264,7 @@ size_t i{0}; }} } -#line 3304 "reflect.h2" +#line 3457 "reflect.h2" [[nodiscard]] auto line_start_token_parse(parse_context& ctx) -> token_ptr { if (ctx.current() != '^' && !((ctx.current() == '\\' && ctx.peek() == 'A'))) {return nullptr; } @@ -5041,29 +5278,43 @@ size_t i{0}; } } -#line 3329 "reflect.h2" - lookahead_token::lookahead_token(cpp2::impl::in positive_) +#line 3483 "reflect.h2" + lookahead_lookbehind_token::lookahead_lookbehind_token(cpp2::impl::in lookahead_, cpp2::impl::in positive_) : regex_token{ "" } + , lookahead{ lookahead_ } , positive{ positive_ }{ -#line 3331 "reflect.h2" +#line 3486 "reflect.h2" } -#line 3333 "reflect.h2" - auto lookahead_token::generate_code(generation_context& ctx) const -> void{ +#line 3488 "reflect.h2" + auto lookahead_lookbehind_token::generate_code(generation_context& ctx) const -> void{ auto inner_name {ctx.generate_func(inner)}; - ctx.add_check("lookahead_token_matcher(" + cpp2::to_string(ctx.match_parameters()) + ", " + cpp2::to_string(cpp2::move(inner_name)) + ")"); + if (lookahead) { + ctx.add_check("lookahead_token_matcher(" + cpp2::to_string(ctx.match_parameters()) + ", " + cpp2::to_string(cpp2::move(inner_name)) + ")"); + } + else { + ctx.add_check("lookbehind_token_matcher(" + cpp2::to_string(ctx.match_parameters()) + ", " + cpp2::to_string(cpp2::move(inner_name)) + ")"); + } + } + +#line 3499 "reflect.h2" + [[nodiscard]] auto lookahead_lookbehind_token::reverse() const -> token_ptr{ + auto r {CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, lookahead, positive)}; + (*cpp2::impl::assert_not_null(r)).inner = inner;// We do not reverse here. Nested lookahead and lookbehind stay as they are. + + return r; } -#line 3339 "reflect.h2" - auto lookahead_token::add_groups(std::set& groups) const -> void{ +#line 3506 "reflect.h2" + auto lookahead_lookbehind_token::add_groups(std::set& groups) const -> void{ (*cpp2::impl::assert_not_null(inner)).add_groups(groups); } - lookahead_token::~lookahead_token() noexcept{} + lookahead_lookbehind_token::~lookahead_lookbehind_token() noexcept{} -#line 3347 "reflect.h2" +#line 3514 "reflect.h2" [[nodiscard]] auto named_class_token_parse(parse_context& ctx) -> token_ptr { if (ctx.current() != '\\') {return nullptr; } @@ -5089,7 +5340,7 @@ size_t i{0}; return CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, "\\" + cpp2::to_string(ctx.current()) + "", "" + cpp2::to_string(cpp2::move(name)) + "::match"); } -#line 3375 "reflect.h2" +#line 3542 "reflect.h2" [[nodiscard]] auto octal_token_parse(parse_context& ctx) -> token_ptr { if (!((ctx.current() == '\\' && ctx.peek() == 'o'))) {return nullptr; } @@ -5115,11 +5366,11 @@ size_t i{0}; return r; } -#line 3412 "reflect.h2" +#line 3579 "reflect.h2" range_token::range_token() : regex_token{ "" }{} -#line 3414 "reflect.h2" +#line 3581 "reflect.h2" [[nodiscard]] auto range_token::parse(parse_context& ctx) -> token_ptr { auto r {CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared)}; @@ -5193,7 +5444,7 @@ size_t i{0}; return nullptr; } -#line 3487 "reflect.h2" +#line 3654 "reflect.h2" auto range_token::parse_modifier(parse_context& ctx) & -> void { if (ctx.peek() == '?') { @@ -5206,7 +5457,7 @@ size_t i{0}; }} } -#line 3499 "reflect.h2" +#line 3666 "reflect.h2" [[nodiscard]] auto range_token::gen_mod_string() const& -> std::string { if (kind == range_flags::not_greedy) { @@ -5220,7 +5471,7 @@ size_t i{0}; }} } -#line 3512 "reflect.h2" +#line 3679 "reflect.h2" [[nodiscard]] auto range_token::gen_range_string() const& -> std::string { std::string r {""}; @@ -5240,7 +5491,18 @@ size_t i{0}; return r; } -#line 3531 "reflect.h2" +#line 3698 "reflect.h2" + [[nodiscard]] auto range_token::reverse() const -> token_ptr{ + auto r {CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared)}; + (*cpp2::impl::assert_not_null(r)).min_count = min_count; + (*cpp2::impl::assert_not_null(r)).max_count = max_count; + (*cpp2::impl::assert_not_null(r)).kind = kind; + (*cpp2::impl::assert_not_null(r)).inner_token = CPP2_UFCS(reverse)((*cpp2::impl::assert_not_null(inner_token))); + + return r; + } + +#line 3708 "reflect.h2" auto range_token::generate_code(generation_context& ctx) const -> void { auto inner_name {ctx.generate_func(inner_token)}; @@ -5252,14 +5514,14 @@ size_t i{0}; ctx.add_statefull(next_name, "cpp2::regex::range_token_matcher::match(" + cpp2::to_string(ctx.match_parameters()) + ", " + cpp2::to_string(cpp2::move(inner_name)) + ", " + cpp2::to_string(cpp2::move(reset_name)) + ", other, " + cpp2::to_string(next_name) + ")"); } -#line 3542 "reflect.h2" +#line 3719 "reflect.h2" auto range_token::add_groups(std::set& groups) const -> void{ (*cpp2::impl::assert_not_null(inner_token)).add_groups(groups); } range_token::~range_token() noexcept{} -#line 3555 "reflect.h2" +#line 3731 "reflect.h2" [[nodiscard]] auto special_range_token::parse(parse_context& ctx) -> token_ptr { auto r {CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared)}; @@ -5283,7 +5545,7 @@ size_t i{0}; if (!(ctx.has_token())) {return ctx.error("'" + cpp2::to_string(ctx.current()) + "' without previous element."); } -#line 3579 "reflect.h2" +#line 3755 "reflect.h2" (*cpp2::impl::assert_not_null(r)).parse_modifier(ctx); (*cpp2::impl::assert_not_null(r)).inner_token = ctx.pop_token(); @@ -5293,7 +5555,23 @@ size_t i{0}; special_range_token::~special_range_token() noexcept{} -#line 3592 "reflect.h2" +#line 3767 "reflect.h2" +[[nodiscard]] auto start_match_parse(parse_context& ctx) -> token_ptr +{ + if (ctx.current() != '\\') {return nullptr; } + + if (ctx.peek() == 'G') { + if (0 != ctx.get_pos()) {return ctx.error("\\G is only supported at the first position in the regex."); } + static_cast(ctx.next()); + ctx.is_start_match = true; + return CPP2_UFCS_TEMPLATE(cpp2_new)(cpp2::shared, "\\G"); + } + else { + return nullptr; + } +} + +#line 3787 "reflect.h2" [[nodiscard]] auto word_boundary_token_parse(parse_context& ctx) -> token_ptr { if (ctx.current() != '\\') {return nullptr; } @@ -5311,15 +5589,15 @@ size_t i{0}; }} } -#line 3628 "reflect.h2" +#line 3823 "reflect.h2" template regex_generator::regex_generator(cpp2::impl::in r, Error_out const& e) : regex{ r } , error_out{ e }{ -#line 3631 "reflect.h2" +#line 3826 "reflect.h2" } -#line 3633 "reflect.h2" +#line 3828 "reflect.h2" template [[nodiscard]] auto regex_generator::parse() & -> std::string { // Extract modifiers and adapt regex. @@ -5331,12 +5609,11 @@ size_t i{0}; } source += "{\n"; - source += " wrap: type = {\n"; // TODO: Remove wrapper when template template parameters are available. - source += " context: type == cpp2::regex::match_context;"; + source += " context: type == cpp2::regex::match_context;"; generation_context gen_ctx {}; source += gen_ctx.run(parse_ctx.get_as_token()); - source += " entry: (cur: Iter, inout ctx: context) -> cpp2::regex::match_return = {\n"; + source += " entry: (cur: Iter, inout ctx: context) -> cpp2::regex::match_return = {\n"; source += " ctx..set_group_start(0, cur);\n"; source += " r := " + cpp2::to_string(gen_ctx.get_entry_func()) + "(cur, ctx, cpp2::regex::true_end_func());\n"; source += " if r.matched { ctx..set_group_end(0, r.pos); }\n"; @@ -5344,10 +5621,11 @@ size_t i{0}; source += " }\n"; source += cpp2::move(gen_ctx).create_named_group_lookup(parse_ctx.named_groups); - source += "}\n"; + source += " is_start_match: () -> bool == " + cpp2::to_string(parse_ctx.is_start_match) + ";"; auto string {(*cpp2::impl::assert_not_null(parse_ctx.get_as_token())).to_string()}; source += " to_string: () -> std::string = { return R\"(" + cpp2::to_string(modifier_escape) + cpp2::to_string(cpp2::move(string)) + cpp2::to_string(modifier_escape) + cpp2::to_string(modifier) + ")\"; }\n"; + source += "}\n"; static_cast(cpp2::move(parse_ctx)); @@ -5355,7 +5633,7 @@ size_t i{0}; return source; } -#line 3668 "reflect.h2" +#line 3863 "reflect.h2" template auto regex_generator::extract_modifiers() & -> void { if (regex.find_first_of("'/") == 0) { @@ -5371,7 +5649,7 @@ size_t i{0}; } } -#line 3684 "reflect.h2" +#line 3879 "reflect.h2" template [[nodiscard]] auto generate_regex(cpp2::impl::in regex, Err const& err) -> std::string { regex_generator parser {regex, err}; @@ -5380,7 +5658,7 @@ template [[nodiscard]] auto generate_regex(cpp2::impl::in void { auto has_default {false}; @@ -5427,15 +5705,15 @@ auto regex_gen(meta::type_declaration& t) -> void auto regular_expression {generate_regex(expr.second, [_0 = t](auto const& message) mutable -> decltype(auto) { return CPP2_UFCS(error)(_0, message); })}; if (!(regular_expression.empty())) { - CPP2_UFCS(add_member)(t, "public " + cpp2::to_string(expr.first) + "_matcher: type = " + cpp2::to_string(cpp2::move(regular_expression)) + ""); - CPP2_UFCS(add_member)(t, "public " + cpp2::to_string(expr.first) + ": cpp2::regex::regular_expression = ();"); + CPP2_UFCS(add_member)(t, "public " + cpp2::to_string(expr.first) + "_matcher: type = " + cpp2::to_string(cpp2::move(regular_expression)) + ""); + CPP2_UFCS(add_member)(t, "public " + cpp2::to_string(expr.first) + ": cpp2::regex::regular_expression> = ();\n"); } } CPP2_UFCS(add_runtime_support_include)(t, "cpp2regex.h"); } -#line 3753 "reflect.h2" +#line 3948 "reflect.h2" [[nodiscard]] auto apply_metafunctions( declaration_node& n, type_declaration& rtype, @@ -5548,7 +5826,7 @@ auto regex_gen(meta::type_declaration& t) -> void return true; } -#line 3866 "reflect.h2" +#line 4061 "reflect.h2" } } diff --git a/source/reflect.h2 b/source/reflect.h2 index 84f6f82556..fe3eac71da 100644 --- a/source/reflect.h2 +++ b/source/reflect.h2 @@ -1675,6 +1675,7 @@ regex_token: @polymorphic_base type = //parse: (inout ctx: parse_context) -> token_ptr; generate_code: (virtual this, inout _: generation_context); // Generate the matching code. + reverse: (virtual this) -> std::shared_ptr; // Create a reverse token for look behind expressions. add_groups: (virtual this, inout _: std::set) = {} // Adds all group indices to the set. to_string: (this) -> std::string = { return string_rep; } // Create a string representation. @@ -1701,6 +1702,8 @@ regex_token_check: @polymorphic_base type = generate_code: (override this, inout ctx: generation_context) = { ctx..add_check(check + "(" + ctx..match_parameters() + ")"); } + + reverse: (override this) -> token_ptr = shared.new(this.to_string(), this.check); } @@ -1720,6 +1723,8 @@ regex_token_code: @polymorphic_base type = generate_code: (override this, inout ctx: generation_context) = { ctx..add(code); } + + reverse: (override this) -> token_ptr = shared.new(this.to_string(), this.code); } @@ -1736,6 +1741,8 @@ regex_token_empty: @polymorphic_base type = generate_code: (override this, inout _: generation_context) = { // Nothing. } + + reverse: (override this) -> token_ptr = shared.new(this.to_string()); } @@ -1771,6 +1778,19 @@ regex_token_list: @polymorphic_base type = } return r; } + + reverse: (override this) -> token_ptr = { + s : int = cpp2::unchecked_narrow(tokens..size()); + + reverse_vec: token_vec = (); + reverse_vec..resize(s); + + i: int = 0; + while i < tokens.ssize() next (i += 1) { + reverse_vec[s - 1 -i] = tokens[i]*.reverse(); + } + return shared.new(reverse_vec); + } } @@ -1890,6 +1910,8 @@ parse_context: type = pos: size_t = 0; // Current parsing position. root: token_ptr; // Token representing the regular expression. + public is_start_match: bool = false; // If the regex contains \G at the beginning. + cur_group_state: parse_context_group_state = (); cur_branch_reset_state: parse_context_branch_reset_state = (); @@ -2212,7 +2234,7 @@ parse_context: type = return true; } - parse_until:(inout this, term: char) -> bool = { + parse_until: (inout this, term: char) -> bool = { cur_token: token_ptr = (); while valid() next _ = next() @@ -2235,6 +2257,7 @@ parse_context: type = if !cur_token && valid() { cur_token = octal_token_parse(this); } if !cur_token && valid() { cur_token = range_token::parse(this); } if !cur_token && valid() { cur_token = special_range_token::parse(this); } + if !cur_token && valid() { cur_token = start_match_parse(this); } if !cur_token && valid() { cur_token = word_boundary_token_parse(this); } // Everything else is matched as it is. @@ -2341,7 +2364,7 @@ generation_context: type = cur := new_context(); cur*.code += "(cur*.tabs)$(name)$: @struct type = {\n"; - cur*.code += "(cur*.tabs)$ operator(): (this, cur: Iter, inout ctx: context, other) -> cpp2::regex::match_return = {\n"; + cur*.code += "(cur*.tabs)$ operator(): (this, cur: Iter, forward ctx, other) -> cpp2::regex::match_return = {\n"; cur*.code += "(cur*.tabs)$ r := ctx..pass(cur);\n"; cur*.code += "(cur*.tabs)$ do {\n"; cur*..add_tabs(3); @@ -2366,6 +2389,7 @@ generation_context: type = cur*.code += "(cur*.tabs)$ else {\n"; cur*.code += "(cur*.tabs)$ r.pos = ctx.end;\n"; cur*.code += "(cur*.tabs)$ }\n"; + cur*.code += "(cur*.tabs)$ _ = ctx;\n"; cur*.code += "(cur*.tabs)$ return r;\n"; cur*.code += "(cur*.tabs)$ }\n"; cur*.code += "(cur*.tabs)$}\n"; @@ -2560,6 +2584,19 @@ alternative_token_gen: @polymorphic_base type = return r; } + + reverse: (override this) -> token_ptr = { + s : int = cpp2::unchecked_narrow(alternatives..size()); + + reverse_vec: token_vec = (); + reverse_vec..resize(s); + + i: int = 0; + while i < s next (i += 1) { + reverse_vec[i] = alternatives[i]*.reverse(); // We only reverse the alternatives, not the order in which they are checked. + } + return shared.new(reverse_vec); + } } @@ -2580,6 +2617,35 @@ any_token: @polymorphic_base type = } } +// Regex syntax: (?>) Example: a(?>bc|c)c +// +atomic_group_token: @polymorphic_base type = +{ + this : regex_token = (""); + + public inner_token : token_ptr = nullptr; + + operator=: (out this) = {} + + reverse: (override this) -> token_ptr = { + r := shared.new(); + r*.inner_token = inner_token*.reverse(); + + return r; + } + + generate_code: (override this, inout ctx: generation_context) = + { + inner_name := ctx..generate_func(inner_token); + + next_name := ctx..next_func_name(); + ctx..add_statefull(next_name, "cpp2::regex::atomic_group_matcher((ctx..match_parameters())$, (inner_name)$, other, (next_name)$)"); + } + + add_groups: (override this, inout groups: std::set) = { + inner_token*..add_groups(groups); + } +} // Regex syntax: a // @@ -2596,6 +2662,12 @@ char_token: @polymorphic_base type = ignore_case = ignore_case_; } + operator=: (out this, t: std::string, ignore_case_: bool) = { + regex_token = (t); + token = t; + ignore_case = ignore_case_; + } + parse: (inout ctx: parse_context) -> token_ptr = { return shared.new(ctx..current(), ctx..get_modifiers()..has(expression_flags::case_insensitive)); } @@ -2677,6 +2749,12 @@ char_token: @polymorphic_base type = return str; } + reverse: (override this) -> token_ptr = { + reverse_str: std::string = token; + std::reverse(reverse_str..begin(), reverse_str..end()); + return shared.new(reverse_str, ignore_case); + } + append: (inout this, that) = { this.token += that.token; this.string_rep += that.string_rep; @@ -2828,6 +2906,15 @@ class_token: @polymorphic_base type = ); } + reverse: (override this) -> token_ptr = { + return shared.new( + negate, + case_insensitive, + class_str, + to_string() + ); + } + generate_code: (override this, inout ctx: generation_context) = { ctx..add_check("class_token_matcher::match((ctx..match_parameters())$)"); @@ -2907,12 +2994,14 @@ group_ref_token: @polymorphic_base type = id : int; case_insensitive: bool; + reverse_eval : bool; - operator=:(out this, id_: int, case_insensitive_: bool, str: std::string) = + operator=:(out this, id_: int, case_insensitive_: bool, reverse_: bool, str: std::string) = { regex_token = str; id = id_; case_insensitive = case_insensitive_; + reverse_eval = reverse_; } parse: (inout ctx: parse_context) -> token_ptr = @@ -3013,11 +3102,15 @@ group_ref_token: @polymorphic_base type = if -1 == group_id { return ctx..error("Group names does not exist. (Name is: (group)$)");} } - return shared.new(group_id, ctx..get_modifiers()..has(expression_flags::case_insensitive), str); + return shared.new(group_id, ctx..get_modifiers()..has(expression_flags::case_insensitive), false, str); + } + + reverse: (override this) -> token_ptr = { + return shared.new(id, case_insensitive, !reverse_eval, to_string()); } generate_code: (override this, inout ctx: generation_context) = { - ctx..add_check("group_ref_token_matcher((ctx..match_parameters())$)"); + ctx..add_check("group_ref_token_matcher((ctx..match_parameters())$)"); } } @@ -3036,20 +3129,39 @@ group_token: @polymorphic_base type = { this: regex_token = (); - number: int = -1; - inner: token_ptr = nullptr; + number: int = -1; + reverse_eval: bool = false; + inner: token_ptr = nullptr; - parse_lookahead: (inout ctx: parse_context, syntax: std::string, positive: bool) -> token_ptr = + parse_lookahead_lookbehind: (inout ctx: parse_context, syntax: std::string, lookahead: bool, positive: bool) -> token_ptr = { _ = ctx..next(); // Skip last token defining the syntax - r := shared.new(positive); + r := shared.new(lookahead, positive); old_state := ctx..start_group(); - if !ctx..parse_until(')') { return ctx..error("Lookahead without a closing bracket."); } + if !ctx..parse_until(')') { return ctx..error("Group without a closing bracket."); } r*.inner = ctx..end_group(old_state); r*..set_string("((syntax)$(r*.inner*..to_string())$)"); + if !lookahead { + r*.inner = r*.inner*..reverse(); + } + + return r; + } + + parse_atomic_pattern: (inout ctx: parse_context, syntax: std::string) -> token_ptr = + { + _ = ctx..next(); // Skip last token defining the syntax + + r := shared.new(); + + old_state := ctx..start_group(); + if !ctx..parse_until(')') { return ctx..error("Group without a closing bracket."); } + r*.inner_token = ctx..end_group(old_state); + r*..set_string("((syntax)$(r*.inner_token*..to_string())$)"); + return r; } @@ -3072,7 +3184,14 @@ group_token: @polymorphic_base type = // Special group if !ctx..next_no_skip() { return ctx..error("Missing character after group opening."); } - if ctx..current() == '<' || ctx..current() == '\'' + if ctx.current() == '<' && (ctx.peek() == '=' || ctx.peek() == '!') + { + // Lookbehind + _ = ctx.next(); // Skip the '<' + + return parse_lookahead_lookbehind(ctx, "?<(ctx..current())$", false, ctx..current() == '='); + } + else if ctx..current() == '<' || ctx..current() == '\'' { // Named group end_char := ctx..current(); @@ -3123,7 +3242,13 @@ group_token: @polymorphic_base type = } else if ctx..current() == '=' || ctx..current() == '!' { - return parse_lookahead(ctx, "?(ctx..current())$", ctx..current() == '='); + // Lookahead + return parse_lookahead_lookbehind(ctx, "?(ctx..current())$", true, ctx..current() == '='); + } + else if ctx..current() == '>' + { + // Atomic pattern + return parse_atomic_pattern(ctx, "?(ctx..current())$"); } else { @@ -3150,10 +3275,19 @@ group_token: @polymorphic_base type = if !ctx..grab_until(':', out name) { return ctx..error("Missing colon for named pattern."); } if name == "pla" || name == "positive_lookahead" { - return parse_lookahead(ctx, "*(name)$:", true); + return parse_lookahead_lookbehind(ctx, "*(name)$:", true, true); } else if name == "nla" || name == "negative_lookahead" { - return parse_lookahead(ctx, "*(name)$:", false); + return parse_lookahead_lookbehind(ctx, "*(name)$:", true, false); + } + else if name == "plb" || name == "positive_lookbehind" { + return parse_lookahead_lookbehind(ctx, "*(name)$:", false, true); + } + else if name == "nlb" || name == "negative_lookbehind" { + return parse_lookahead_lookbehind(ctx, "*(name)$:", false, false); + } + else if name == "atomic" { + return parse_atomic_pattern(ctx, "*(name)$:"); } else { return ctx..error("Unknown named group pattern: '(name)$'"); @@ -3190,6 +3324,14 @@ group_token: @polymorphic_base type = } } + reverse: (override this) -> token_ptr = { + r := shared.new(); + r*.number = number; + r*.reverse_eval = !reverse_eval; + r*.inner = inner*.reverse(); + return r; + } + gen_string: (name: std::string, name_brackets: bool, has_modifier: bool, modifiers: std::string, inner_: token_ptr) -> std::string = { start : std::string = "("; @@ -3211,12 +3353,23 @@ group_token: @polymorphic_base type = generate_code: (override this, inout ctx: generation_context) = { if -1 != number { - ctx..add("ctx..set_group_start((number)$, r.pos);"); + if reverse_eval { + ctx..add("ctx..set_group_end((number)$, r.pos);"); + } + else { + ctx..add("ctx..set_group_start((number)$, r.pos);"); + } } inner*..generate_code(ctx); if -1 != number { - ctx..add("ctx..set_group_end((number)$, r.pos);"); + if reverse_eval { + ctx..add("ctx..set_group_start((number)$, r.pos);"); + } + else { + ctx..add("ctx..set_group_end((number)$, r.pos);"); + } + tmp_name := ctx..gen_temp(); ctx..add("(tmp_name)$_func := :() = {"); ctx..add(" if !r&$*.matched {"); @@ -3319,21 +3472,35 @@ line_start_token_parse: (inout ctx: parse_context) -> token_ptr = // // Parsed in group_token. // -lookahead_token: @polymorphic_base type = +lookahead_lookbehind_token: @polymorphic_base type = { this: regex_token = (""); - protected positive: bool; - public inner : token_ptr = nullptr; + protected lookahead: bool; + protected positive: bool; + public inner : token_ptr = nullptr; - operator=: (out this, positive_: bool) = { - positive = positive_; + operator=: (out this, lookahead_: bool, positive_: bool) = { + lookahead = lookahead_; + positive = positive_; } generate_code: (override this, inout ctx: generation_context) = { inner_name := ctx..generate_func(inner); - ctx..add_check("lookahead_token_matcher((ctx..match_parameters())$, (inner_name)$)"); + if lookahead { + ctx..add_check("lookahead_token_matcher((ctx..match_parameters())$, (inner_name)$)"); + } + else { + ctx..add_check("lookbehind_token_matcher((ctx..match_parameters())$, (inner_name)$)"); + } + } + + reverse: (override this) -> token_ptr = { + r := shared.new(lookahead, positive); + r*.inner = inner; // We do not reverse here. Nested lookahead and lookbehind stay as they are. + + return r; } add_groups: (override this, inout groups: std::set) = { @@ -3528,6 +3695,16 @@ range_token: @polymorphic_base type = return r; } + reverse: (override this) -> token_ptr = { + r := shared.new(); + r*.min_count = min_count; + r*.max_count = max_count; + r*.kind = kind; + r*.inner_token = inner_token*.reverse(); + + return r; + } + generate_code: (override this, inout ctx: generation_context) = { inner_name := ctx..generate_func(inner_token); @@ -3542,7 +3719,6 @@ range_token: @polymorphic_base type = add_groups: (override this, inout groups: std::set) = { inner_token*..add_groups(groups); } - } @@ -3584,6 +3760,25 @@ special_range_token: @polymorphic_base type = } } +// Regex syntax: \G Example: \Gaa +// +// Forces the match and/or consecutive matches to start at the position of the last match. +// +start_match_parse: (inout ctx: parse_context) -> token_ptr = +{ + if ctx..current() != '\\' { return nullptr; } + + if ctx..peek() == 'G' { + if 0 != ctx..get_pos() { return ctx..error("\\G is only supported at the first position in the regex."); } + _ = ctx..next(); + ctx.is_start_match = true; + return shared.new("\\G"); + } + else { + return nullptr; + } +} + // Regex syntax: \b or \B Example: \bword\b // @@ -3641,12 +3836,11 @@ regex_generator: type = } source += "{\n"; - source += " wrap: type = {\n"; // TODO: Remove wrapper when template template parameters are available. - source += " context: type == cpp2::regex::match_context;"; + source += " context: type == cpp2::regex::match_context;"; gen_ctx: generation_context = (); source += gen_ctx..run(parse_ctx..get_as_token()); - source += " entry: (cur: Iter, inout ctx: context) -> cpp2::regex::match_return = {\n"; + source += " entry: (cur: Iter, inout ctx: context) -> cpp2::regex::match_return = {\n"; source += " ctx..set_group_start(0, cur);\n"; source += " r := (gen_ctx..get_entry_func())$(cur, ctx, cpp2::regex::true_end_func());\n"; source += " if r.matched { ctx..set_group_end(0, r.pos); }\n"; @@ -3654,10 +3848,11 @@ regex_generator: type = source += " }\n"; source += gen_ctx..create_named_group_lookup(parse_ctx.named_groups); - source += "}\n"; + source += " is_start_match: () -> bool == (parse_ctx.is_start_match)$;"; string := parse_ctx..get_as_token()*..to_string(); source += " to_string: () -> std::string = { return R\"((modifier_escape)$(string)$(modifier_escape)$(modifier)$)\"; }\n"; + source += "}\n"; _ = parse_ctx; @@ -3737,8 +3932,8 @@ regex_gen: (inout t: meta::type_declaration) = regular_expression := generate_regex(expr.second, :(message) = t$.error(message);); if !regular_expression..empty() { - t.add_member("public (expr.first)$_matcher: type = (regular_expression)$"); - t.add_member("public (expr.first)$: cpp2::regex::regular_expression = ();"); + t.add_member("public (expr.first)$_matcher: type = (regular_expression)$"); + t.add_member("public (expr.first)$: cpp2::regex::regular_expression> = ();\n"); } }