19#if ADA_INCLUDE_URL_PATTERN
20template <url_pattern_regex::regex_concept regex_prov
ider>
21tl::expected<url_pattern<regex_provider>,
errors> parse_url_pattern_impl(
22 std::variant<std::string_view, url_pattern_init>&& input,
23 const std::string_view* base_url,
const url_pattern_options* options) {
25 url_pattern_init init;
28 if (std::holds_alternative<std::string_view>(input)) {
31 url_pattern_helpers::constructor_string_parser<regex_provider>::parse(
32 std::get<std::string_view>(input));
34 ada_log(
"constructor_string_parser::parse failed");
35 return tl::unexpected(parse_result.error());
37 init = std::move(*parse_result);
40 if (!base_url && !init.protocol) {
41 ada_log(
"base url is null and protocol is not set");
47 init.base_url = std::string(*base_url);
54 ada_log(
"base url is not null");
59 init = std::move(std::get<url_pattern_init>(input));
65 url_pattern_init::process(init, url_pattern_init::process_type::pattern);
66 if (!processed_init) {
67 ada_log(
"url_pattern_init::process failed for init and 'pattern'");
68 return tl::unexpected(processed_init.error());
75 if (!processed_init->protocol) processed_init->protocol =
"*";
76 if (!processed_init->username) processed_init->username =
"*";
77 if (!processed_init->password) processed_init->password =
"*";
78 if (!processed_init->hostname) processed_init->hostname =
"*";
79 if (!processed_init->port) processed_init->port =
"*";
80 if (!processed_init->pathname) processed_init->pathname =
"*";
81 if (!processed_init->search) processed_init->search =
"*";
82 if (!processed_init->hash) processed_init->hash =
"*";
84 ada_log(
"-- processed_init->protocol: ", processed_init->protocol.value());
85 ada_log(
"-- processed_init->username: ", processed_init->username.value());
86 ada_log(
"-- processed_init->password: ", processed_init->password.value());
87 ada_log(
"-- processed_init->hostname: ", processed_init->hostname.value());
88 ada_log(
"-- processed_init->port: ", processed_init->port.value());
89 ada_log(
"-- processed_init->pathname: ", processed_init->pathname.value());
90 ada_log(
"-- processed_init->search: ", processed_init->search.value());
91 ada_log(
"-- processed_init->hash: ", processed_init->hash.value());
97 if (scheme::is_special(*processed_init->protocol)) {
102 if (default_port != 0 &&
103 std::to_string(default_port) == processed_init->port.value()) {
104 processed_init->port->clear();
109 url_pattern<regex_provider> url_pattern_{};
114 auto protocol_component = url_pattern_component<regex_provider>::compile(
115 processed_init->protocol.value(),
116 url_pattern_helpers::canonicalize_protocol,
117 url_pattern_compile_component_options::DEFAULT);
118 if (!protocol_component) {
119 ada_log(
"url_pattern_component::compile failed for protocol ",
120 processed_init->protocol.value());
121 return tl::unexpected(protocol_component.error());
123 url_pattern_.protocol_component = std::move(*protocol_component);
128 auto username_component = url_pattern_component<regex_provider>::compile(
129 processed_init->username.value(),
130 url_pattern_helpers::canonicalize_username,
131 url_pattern_compile_component_options::DEFAULT);
132 if (!username_component) {
133 ada_log(
"url_pattern_component::compile failed for username ",
134 processed_init->username.value());
135 return tl::unexpected(username_component.error());
137 url_pattern_.username_component = std::move(*username_component);
142 auto password_component = url_pattern_component<regex_provider>::compile(
143 processed_init->password.value(),
144 url_pattern_helpers::canonicalize_password,
145 url_pattern_compile_component_options::DEFAULT);
146 if (!password_component) {
147 ada_log(
"url_pattern_component::compile failed for password ",
148 processed_init->password.value());
149 return tl::unexpected(password_component.error());
151 url_pattern_.password_component = std::move(*password_component);
159 if (url_pattern_helpers::is_ipv6_address(processed_init->hostname.value())) {
160 ada_log(
"processed_init->hostname is ipv6 address");
164 auto hostname_component = url_pattern_component<regex_provider>::compile(
165 processed_init->hostname.value(),
166 url_pattern_helpers::canonicalize_ipv6_hostname,
167 url_pattern_compile_component_options::DEFAULT);
168 if (!hostname_component) {
169 ada_log(
"url_pattern_component::compile failed for ipv6 hostname ",
170 processed_init->hostname.value());
171 return tl::unexpected(hostname_component.error());
173 url_pattern_.hostname_component = std::move(*hostname_component);
178 auto hostname_component = url_pattern_component<regex_provider>::compile(
179 processed_init->hostname.value(),
180 url_pattern_helpers::canonicalize_hostname,
181 url_pattern_compile_component_options::HOSTNAME);
182 if (!hostname_component) {
183 ada_log(
"url_pattern_component::compile failed for hostname ",
184 processed_init->hostname.value());
185 return tl::unexpected(hostname_component.error());
187 url_pattern_.hostname_component = std::move(*hostname_component);
192 auto port_component = url_pattern_component<regex_provider>::compile(
193 processed_init->port.value(), url_pattern_helpers::canonicalize_port,
194 url_pattern_compile_component_options::DEFAULT);
195 if (!port_component) {
196 ada_log(
"url_pattern_component::compile failed for port ",
197 processed_init->port.value());
198 return tl::unexpected(port_component.error());
200 url_pattern_.port_component = std::move(*port_component);
204 auto compile_options = url_pattern_compile_component_options::DEFAULT;
206 compile_options.ignore_case = options->ignore_case;
209 url_pattern_.ignore_case_ = options->ignore_case;
215 if (url_pattern_helpers::protocol_component_matches_special_scheme<
219 auto path_compile_options = url_pattern_compile_component_options::PATHNAME;
221 path_compile_options.ignore_case = options->ignore_case;
227 auto pathname_component = url_pattern_component<regex_provider>::compile(
228 processed_init->pathname.value(),
229 url_pattern_helpers::canonicalize_pathname, path_compile_options);
230 if (!pathname_component) {
231 ada_log(
"url_pattern_component::compile failed for pathname ",
232 processed_init->pathname.value());
233 return tl::unexpected(pathname_component.error());
235 url_pattern_.pathname_component = std::move(*pathname_component);
240 auto pathname_component = url_pattern_component<regex_provider>::compile(
241 processed_init->pathname.value(),
242 url_pattern_helpers::canonicalize_opaque_pathname, compile_options);
243 if (!pathname_component) {
244 ada_log(
"url_pattern_component::compile failed for opaque pathname ",
245 processed_init->pathname.value());
246 return tl::unexpected(pathname_component.error());
248 url_pattern_.pathname_component = std::move(*pathname_component);
253 auto search_component = url_pattern_component<regex_provider>::compile(
254 processed_init->search.value(), url_pattern_helpers::canonicalize_search,
256 if (!search_component) {
257 ada_log(
"url_pattern_component::compile failed for search ",
258 processed_init->search.value());
259 return tl::unexpected(search_component.error());
261 url_pattern_.search_component = std::move(*search_component);
265 auto hash_component = url_pattern_component<regex_provider>::compile(
266 processed_init->hash.value(), url_pattern_helpers::canonicalize_hash,
268 if (!hash_component) {
269 ada_log(
"url_pattern_component::compile failed for hash ",
270 processed_init->hash.value());
271 return tl::unexpected(hash_component.error());
273 url_pattern_.hash_component = std::move(*hash_component);