Ada 4.1.1
Fast spec-compliant URL parser
Loading...
Searching...
No Matches
ada_c.cpp
Go to the documentation of this file.
1// NOLINTBEGIN(bugprone-exception-escape,
2// bugprone-suspicious-stringview-data-usage)
5
8}
9
10extern "C" {
11typedef void* ada_url;
13typedef void* ada_strings;
17
18struct ada_string {
19 const char* data;
20 size_t length;
21};
22
23struct ada_owned_string {
24 const char* data;
25 size_t length;
26};
27
28struct ada_string_pair {
29 ada_string key;
30 ada_string value;
31};
32
33ada_string ada_string_create(const char* data, size_t length) {
34 ada_string out{};
35 out.data = data;
36 out.length = length;
37 return out;
38}
39
40struct ada_url_components {
41 /*
42 * By using 32-bit integers, we implicitly assume that the URL string
43 * cannot exceed 4 GB.
44 *
45 * https://user:pass@example.com:1234/foo/bar?baz#quux
46 * | | | | ^^^^| | |
47 * | | | | | | | `----- hash_start
48 * | | | | | | `--------- search_start
49 * | | | | | `----------------- pathname_start
50 * | | | | `--------------------- port
51 * | | | `----------------------- host_end
52 * | | `---------------------------------- host_start
53 * | `--------------------------------------- username_end
54 * `--------------------------------------------- protocol_end
55 */
56 uint32_t protocol_end;
61 uint32_t username_end;
62 uint32_t host_start;
63 uint32_t host_end;
64 uint32_t port;
65 uint32_t pathname_start;
66 uint32_t search_start;
67 uint32_t hash_start;
68};
69
70ada_url ada_parse(const char* input, size_t length) noexcept {
72 ada::parse<ada::url_aggregator>(std::string_view(input, length)));
73}
74
75ada_url ada_parse_with_base(const char* input, size_t input_length,
76 const char* base, size_t base_length) noexcept {
77 auto base_out =
78 ada::parse<ada::url_aggregator>(std::string_view(base, base_length));
79
80 if (!base_out) {
81 return new ada::result<ada::url_aggregator>(base_out);
82 }
83
85 std::string_view(input, input_length), &base_out.value()));
86}
87
88bool ada_can_parse(const char* input, size_t length) noexcept {
89 return ada::can_parse(std::string_view(input, length));
90}
91
92bool ada_can_parse_with_base(const char* input, size_t input_length,
93 const char* base, size_t base_length) noexcept {
94 std::string_view base_view(base, base_length);
95 return ada::can_parse(std::string_view(input, input_length), &base_view);
96}
97
98void ada_free(ada_url result) noexcept {
99 auto* r = (ada::result<ada::url_aggregator>*)result;
100 delete r;
101}
102
107
108bool ada_is_valid(ada_url result) noexcept {
110 return r.has_value();
111}
112
113// caller must free the result with ada_free_owned_string
116 ada_owned_string owned{};
117 if (!r) {
118 owned.data = nullptr;
119 owned.length = 0;
120 return owned;
121 }
122 std::string out = r->get_origin();
123 owned.length = out.size();
124 // +1 for a trailing NUL. length does not include it. (#1307)
125 owned.data = new char[owned.length + 1];
126 memcpy((void*)owned.data, out.data(), owned.length);
127 const_cast<char*>(owned.data)[owned.length] = '\0';
128 return owned;
129}
130
132 delete[] owned.data;
133}
134
137 if (!r) {
138 return ada_string_create(nullptr, 0);
139 }
140 std::string_view out = r->get_href();
141 return ada_string_create(out.data(), out.length());
142}
143
146 if (!r) {
147 return ada_string_create(nullptr, 0);
148 }
149 std::string_view out = r->get_username();
150 return ada_string_create(out.data(), out.length());
151}
152
155 if (!r) {
156 return ada_string_create(nullptr, 0);
157 }
158 std::string_view out = r->get_password();
159 return ada_string_create(out.data(), out.length());
160}
161
164 if (!r) {
165 return ada_string_create(nullptr, 0);
166 }
167 std::string_view out = r->get_port();
168 return ada_string_create(out.data(), out.length());
169}
170
173 if (!r) {
174 return ada_string_create(nullptr, 0);
175 }
176 std::string_view out = r->get_hash();
177 return ada_string_create(out.data(), out.length());
178}
179
182 if (!r) {
183 return ada_string_create(nullptr, 0);
184 }
185 std::string_view out = r->get_host();
186 return ada_string_create(out.data(), out.length());
187}
188
191 if (!r) {
192 return ada_string_create(nullptr, 0);
193 }
194 std::string_view out = r->get_hostname();
195 return ada_string_create(out.data(), out.length());
196}
197
200 if (!r) {
201 return ada_string_create(nullptr, 0);
202 }
203 std::string_view out = r->get_pathname();
204 return ada_string_create(out.data(), out.length());
205}
206
209 if (!r) {
210 return ada_string_create(nullptr, 0);
211 }
212 std::string_view out = r->get_search();
213 return ada_string_create(out.data(), out.length());
214}
215
218 if (!r) {
219 return ada_string_create(nullptr, 0);
220 }
221 std::string_view out = r->get_protocol();
222 return ada_string_create(out.data(), out.length());
223}
224
225uint8_t ada_get_host_type(ada_url result) noexcept {
227 if (!r) {
228 return 0;
229 }
230 return r->host_type;
231}
232
233uint8_t ada_get_scheme_type(ada_url result) noexcept {
235 if (!r) {
236 return 0;
237 }
238 return r->type;
239}
240
241bool ada_set_href(ada_url result, const char* input, size_t length) noexcept {
243 if (!r) {
244 return false;
245 }
246 return r->set_href(std::string_view(input, length));
247}
248
249bool ada_set_host(ada_url result, const char* input, size_t length) noexcept {
251 if (!r) {
252 return false;
253 }
254 return r->set_host(std::string_view(input, length));
255}
256
257bool ada_set_hostname(ada_url result, const char* input,
258 size_t length) noexcept {
260 if (!r) {
261 return false;
262 }
263 return r->set_hostname(std::string_view(input, length));
264}
265
266bool ada_set_protocol(ada_url result, const char* input,
267 size_t length) noexcept {
269 if (!r) {
270 return false;
271 }
272 return r->set_protocol(std::string_view(input, length));
273}
274
275bool ada_set_username(ada_url result, const char* input,
276 size_t length) noexcept {
278 if (!r) {
279 return false;
280 }
281 return r->set_username(std::string_view(input, length));
282}
283
284bool ada_set_password(ada_url result, const char* input,
285 size_t length) noexcept {
287 if (!r) {
288 return false;
289 }
290 return r->set_password(std::string_view(input, length));
291}
292
293bool ada_set_port(ada_url result, const char* input, size_t length) noexcept {
295 if (!r) {
296 return false;
297 }
298 return r->set_port(std::string_view(input, length));
299}
300
301bool ada_set_pathname(ada_url result, const char* input,
302 size_t length) noexcept {
304 if (!r) {
305 return false;
306 }
307 return r->set_pathname(std::string_view(input, length));
308}
309
317void ada_set_search(ada_url result, const char* input, size_t length) noexcept {
319 if (r) {
320 r->set_search(std::string_view(input, length));
321 }
322}
323
331void ada_set_hash(ada_url result, const char* input, size_t length) noexcept {
333 if (r) {
334 r->set_hash(std::string_view(input, length));
335 }
336}
337
338void ada_clear_port(ada_url result) noexcept {
340 if (r) {
341 r->clear_port();
342 }
343}
344
351void ada_clear_hash(ada_url result) noexcept {
353 if (r) {
354 r->clear_hash();
355 }
356}
357
364void ada_clear_search(ada_url result) noexcept {
366 if (r) {
367 r->clear_search();
368 }
369}
370
371bool ada_has_credentials(ada_url result) noexcept {
373 if (!r) {
374 return false;
375 }
376 return r->has_credentials();
377}
378
379bool ada_has_empty_hostname(ada_url result) noexcept {
381 if (!r) {
382 return false;
383 }
384 return r->has_empty_hostname();
385}
386
387bool ada_has_hostname(ada_url result) noexcept {
389 if (!r) {
390 return false;
391 }
392 return r->has_hostname();
393}
394
395bool ada_has_non_empty_username(ada_url result) noexcept {
397 if (!r) {
398 return false;
399 }
400 return r->has_non_empty_username();
401}
402
403bool ada_has_non_empty_password(ada_url result) noexcept {
405 if (!r) {
406 return false;
407 }
408 return r->has_non_empty_password();
409}
410
411bool ada_has_port(ada_url result) noexcept {
413 if (!r) {
414 return false;
415 }
416 return r->has_port();
417}
418
419bool ada_has_password(ada_url result) noexcept {
421 if (!r) {
422 return false;
423 }
424 return r->has_password();
425}
426
427bool ada_has_hash(ada_url result) noexcept {
429 if (!r) {
430 return false;
431 }
432 return r->has_hash();
433}
434
435bool ada_has_search(ada_url result) noexcept {
437 if (!r) {
438 return false;
439 }
440 return r->has_search();
441}
442
443// returns a pointer to the internal url_aggregator::url_components
445 static_assert(sizeof(ada_url_components) == sizeof(ada::url_components));
447 if (!r) {
448 return nullptr;
449 }
450 return reinterpret_cast<const ada_url_components*>(&r->get_components());
451}
452
453ada_owned_string ada_idna_to_unicode(const char* input, size_t length) {
454 std::string out = ada::idna::to_unicode(std::string_view(input, length));
455 ada_owned_string owned{};
456 owned.length = out.length();
457 owned.data = new char[owned.length + 1];
458 memcpy((void*)owned.data, out.data(), owned.length);
459 const_cast<char*>(owned.data)[owned.length] = '\0';
460 return owned;
461}
462
463ada_owned_string ada_idna_to_ascii(const char* input, size_t length) {
464 std::string out = ada::idna::to_ascii(std::string_view(input, length));
465 ada_owned_string owned{};
466 owned.length = out.size();
467 owned.data = new char[owned.length + 1];
468 memcpy((void*)owned.data, out.data(), owned.length);
469 const_cast<char*>(owned.data)[owned.length] = '\0';
470 return owned;
471}
472
474 size_t length) {
476 ada::url_search_params(std::string_view(input, length)));
477}
478
480 auto* r = (ada::result<ada::url_search_params>*)result;
481 delete r;
482}
483
487 if (!r) return ada_owned_string{nullptr, 0};
488 std::string out = r->to_string();
489 ada_owned_string owned{};
490 owned.length = out.size();
491 owned.data = new char[owned.length + 1];
492 memcpy((void*)owned.data, out.data(), owned.length);
493 const_cast<char*>(owned.data)[owned.length] = '\0';
494 return owned;
495}
496
500 if (!r) {
501 return 0;
502 }
503 return r->size();
504}
505
509 if (r) {
510 r->sort();
511 }
512}
513
514void ada_search_params_reset(ada_url_search_params result, const char* input,
515 size_t length) {
518 if (r) {
519 r->reset(std::string_view(input, length));
520 }
521}
522
524 size_t key_length, const char* value,
525 size_t value_length) {
528 if (r) {
529 r->append(std::string_view(key, key_length),
530 std::string_view(value, value_length));
531 }
532}
533
534void ada_search_params_set(ada_url_search_params result, const char* key,
535 size_t key_length, const char* value,
536 size_t value_length) {
539 if (r) {
540 r->set(std::string_view(key, key_length),
541 std::string_view(value, value_length));
542 }
543}
544
546 size_t key_length) {
549 if (r) {
550 r->remove(std::string_view(key, key_length));
551 }
552}
553
555 const char* key, size_t key_length,
556 const char* value, size_t value_length) {
559 if (r) {
560 r->remove(std::string_view(key, key_length),
561 std::string_view(value, value_length));
562 }
563}
564
565bool ada_search_params_has(ada_url_search_params result, const char* key,
566 size_t key_length) {
569 if (!r) {
570 return false;
571 }
572 return r->has(std::string_view(key, key_length));
573}
574
576 size_t key_length, const char* value,
577 size_t value_length) {
580 if (!r) {
581 return false;
582 }
583 return r->has(std::string_view(key, key_length),
584 std::string_view(value, value_length));
585}
586
588 size_t key_length) {
591 if (!r) {
592 return ada_string_create(nullptr, 0);
593 }
594 auto found = r->get(std::string_view(key, key_length));
595 if (!found.has_value()) {
596 return ada_string_create(nullptr, 0);
597 }
598 return ada_string_create(found->data(), found->length());
599}
600
602 const char* key, size_t key_length) {
605 if (!r) {
607 std::vector<std::string>());
608 }
610 r->get_all(std::string_view(key, key_length)));
611}
612
613// next() returns views into the iterator's params, so each C iterator owns a
614// copy that outlives ada_free_search_params and later mutations.
619
624
629
639
649
659
661 auto* r = (ada::result<std::vector<std::string>>*)result;
662 delete r;
663}
664
666 auto* r = (ada::result<std::vector<std::string>>*)result;
667 if (!r) {
668 return 0;
669 }
670 return (*r)->size();
671}
672
674 auto* r = (ada::result<std::vector<std::string>>*)result;
675 if (!r || index >= (*r)->size()) {
676 return ada_string_create(nullptr, 0);
677 }
678 std::string_view view = (*r)->at(index);
679 return ada_string_create(view.data(), view.length());
680}
681
686
689 auto* r = (ada_c_search_params_keys_iter*)result;
690 if (!r) {
691 return ada_string_create(nullptr, 0);
692 }
693 auto next = r->iter.next();
694 if (!next.has_value()) {
695 return ada_string_create(nullptr, 0);
696 }
697 return ada_string_create(next->data(), next->length());
698}
699
702 auto* r = (ada_c_search_params_keys_iter*)result;
703 if (!r) {
704 return false;
705 }
706 return r->iter.has_next();
707}
708
714
717 auto* r = (ada_c_search_params_values_iter*)result;
718 if (!r) {
719 return ada_string_create(nullptr, 0);
720 }
721 auto next = r->iter.next();
722 if (!next.has_value()) {
723 return ada_string_create(nullptr, 0);
724 }
725 return ada_string_create(next->data(), next->length());
726}
727
730 auto* r = (ada_c_search_params_values_iter*)result;
731 if (!r) {
732 return false;
733 }
734 return r->iter.has_next();
735}
736
742
745 auto* r = (ada_c_search_params_entries_iter*)result;
746 if (!r) return {ada_string_create(nullptr, 0), ada_string_create(nullptr, 0)};
747 auto next = r->iter.next();
748 if (!next.has_value()) {
749 return {ada_string_create(nullptr, 0), ada_string_create(nullptr, 0)};
750 }
751 return ada_string_pair{
752 ada_string_create(next->first.data(), next->first.length()),
753 ada_string_create(next->second.data(), next->second.length())};
754}
755
758 auto* r = (ada_c_search_params_entries_iter*)result;
759 if (!r) {
760 return false;
761 }
762 return r->iter.has_next();
763}
764
765void ada_set_max_input_length(uint32_t length) noexcept {
767}
768
769uint32_t ada_get_max_input_length() noexcept {
771}
772
773typedef struct {
774 int major;
775 int minor;
776 int revision;
778
779const char* ada_get_version() { return ADA_VERSION; }
780
788
789} // extern "C"
790// NOLINTEND(bugprone-exception-escape,
791// bugprone-suspicious-stringview-data-usage)
void ada_set_max_input_length(uint32_t length) noexcept
Definition ada_c.cpp:765
ada_url_search_params ada_parse_search_params(const char *input, size_t length)
Definition ada_c.cpp:473
ada_string ada_get_search(ada_url result) noexcept
Definition ada_c.cpp:207
ada_strings ada_search_params_get_all(ada_url_search_params result, const char *key, size_t key_length)
Definition ada_c.cpp:601
uint8_t ada_get_scheme_type(ada_url result) noexcept
Definition ada_c.cpp:233
bool ada_has_search(ada_url result) noexcept
Definition ada_c.cpp:435
void ada_free_search_params_entries_iter(ada_url_search_params_entries_iter result)
Definition ada_c.cpp:737
bool ada_search_params_keys_iter_has_next(ada_url_search_params_keys_iter result)
Definition ada_c.cpp:700
ada_string ada_search_params_values_iter_next(ada_url_search_params_values_iter result)
Definition ada_c.cpp:715
void ada_free_search_params_keys_iter(ada_url_search_params_keys_iter result)
Definition ada_c.cpp:682
void ada_clear_hash(ada_url result) noexcept
Definition ada_c.cpp:351
bool ada_search_params_has_value(ada_url_search_params result, const char *key, size_t key_length, const char *value, size_t value_length)
Definition ada_c.cpp:575
void ada_free_strings(ada_strings result)
Definition ada_c.cpp:660
void ada_search_params_append(ada_url_search_params result, const char *key, size_t key_length, const char *value, size_t value_length)
Definition ada_c.cpp:523
ada_url_search_params_entries_iter ada_search_params_get_entries(ada_url_search_params result)
Definition ada_c.cpp:650
ada_string ada_search_params_get(ada_url_search_params result, const char *key, size_t key_length)
Definition ada_c.cpp:587
void ada_free(ada_url result) noexcept
Definition ada_c.cpp:98
bool ada_can_parse_with_base(const char *input, size_t input_length, const char *base, size_t base_length) noexcept
Definition ada_c.cpp:92
void ada_free_owned_string(ada_owned_string owned) noexcept
Definition ada_c.cpp:131
ada_url ada_parse(const char *input, size_t length) noexcept
Definition ada_c.cpp:70
const char * ada_get_version()
Definition ada_c.cpp:779
ada_version_components ada_get_version_components()
Definition ada_c.cpp:781
uint8_t ada_get_host_type(ada_url result) noexcept
Definition ada_c.cpp:225
ada_string ada_get_protocol(ada_url result) noexcept
Definition ada_c.cpp:216
void ada_search_params_sort(ada_url_search_params result)
Definition ada_c.cpp:506
bool ada_has_credentials(ada_url result) noexcept
Definition ada_c.cpp:371
bool ada_set_pathname(ada_url result, const char *input, size_t length) noexcept
Definition ada_c.cpp:301
ada_string ada_get_host(ada_url result) noexcept
Definition ada_c.cpp:180
bool ada_set_password(ada_url result, const char *input, size_t length) noexcept
Definition ada_c.cpp:284
ada_string ada_get_port(ada_url result) noexcept
Definition ada_c.cpp:162
ada_string ada_string_create(const char *data, size_t length)
Definition ada_c.cpp:33
ada::result< ada::url_aggregator > & get_instance(void *result) noexcept
Definition ada_c.cpp:6
ada_owned_string ada_idna_to_unicode(const char *input, size_t length)
Definition ada_c.cpp:453
ada_string ada_get_hash(ada_url result) noexcept
Definition ada_c.cpp:171
ada_owned_string ada_get_origin(ada_url result) noexcept
Definition ada_c.cpp:114
void ada_search_params_remove_value(ada_url_search_params result, const char *key, size_t key_length, const char *value, size_t value_length)
Definition ada_c.cpp:554
ada_string ada_get_hostname(ada_url result) noexcept
Definition ada_c.cpp:189
void ada_free_search_params(ada_url_search_params result)
Definition ada_c.cpp:479
bool ada_set_username(ada_url result, const char *input, size_t length) noexcept
Definition ada_c.cpp:275
bool ada_has_empty_hostname(ada_url result) noexcept
Definition ada_c.cpp:379
bool ada_has_hash(ada_url result) noexcept
Definition ada_c.cpp:427
ada_string ada_get_href(ada_url result) noexcept
Definition ada_c.cpp:135
ada_string ada_get_password(ada_url result) noexcept
Definition ada_c.cpp:153
bool ada_set_protocol(ada_url result, const char *input, size_t length) noexcept
Definition ada_c.cpp:266
bool ada_can_parse(const char *input, size_t length) noexcept
Definition ada_c.cpp:88
bool ada_is_valid(ada_url result) noexcept
Definition ada_c.cpp:108
ada_owned_string ada_search_params_to_string(ada_url_search_params result)
Definition ada_c.cpp:484
ada_string ada_strings_get(ada_strings result, size_t index)
Definition ada_c.cpp:673
void ada_set_search(ada_url result, const char *input, size_t length) noexcept
Definition ada_c.cpp:317
const ada_url_components * ada_get_components(ada_url result) noexcept
Definition ada_c.cpp:444
bool ada_search_params_entries_iter_has_next(ada_url_search_params_entries_iter result)
Definition ada_c.cpp:756
size_t ada_search_params_size(ada_url_search_params result)
Definition ada_c.cpp:497
ada_string ada_get_pathname(ada_url result) noexcept
Definition ada_c.cpp:198
void ada_free_search_params_values_iter(ada_url_search_params_values_iter result)
Definition ada_c.cpp:709
ada_url ada_parse_with_base(const char *input, size_t input_length, const char *base, size_t base_length) noexcept
Definition ada_c.cpp:75
ada_string ada_search_params_keys_iter_next(ada_url_search_params_keys_iter result)
Definition ada_c.cpp:687
void ada_clear_port(ada_url result) noexcept
Definition ada_c.cpp:338
bool ada_set_hostname(ada_url result, const char *input, size_t length) noexcept
Definition ada_c.cpp:257
bool ada_has_hostname(ada_url result) noexcept
Definition ada_c.cpp:387
ada_string_pair ada_search_params_entries_iter_next(ada_url_search_params_entries_iter result)
Definition ada_c.cpp:743
ada_url_search_params_keys_iter ada_search_params_get_keys(ada_url_search_params result)
Definition ada_c.cpp:630
ada_owned_string ada_idna_to_ascii(const char *input, size_t length)
Definition ada_c.cpp:463
bool ada_has_non_empty_password(ada_url result) noexcept
Definition ada_c.cpp:403
bool ada_set_href(ada_url result, const char *input, size_t length) noexcept
Definition ada_c.cpp:241
ada_url ada_copy(ada_url input) noexcept
Definition ada_c.cpp:103
bool ada_has_password(ada_url result) noexcept
Definition ada_c.cpp:419
bool ada_search_params_values_iter_has_next(ada_url_search_params_values_iter result)
Definition ada_c.cpp:728
bool ada_set_port(ada_url result, const char *input, size_t length) noexcept
Definition ada_c.cpp:293
bool ada_has_port(ada_url result) noexcept
Definition ada_c.cpp:411
void ada_search_params_set(ada_url_search_params result, const char *key, size_t key_length, const char *value, size_t value_length)
Definition ada_c.cpp:534
bool ada_set_host(ada_url result, const char *input, size_t length) noexcept
Definition ada_c.cpp:249
uint32_t ada_get_max_input_length() noexcept
Definition ada_c.cpp:769
size_t ada_strings_size(ada_strings result)
Definition ada_c.cpp:665
ada_url_search_params_values_iter ada_search_params_get_values(ada_url_search_params result)
Definition ada_c.cpp:640
void ada_set_hash(ada_url result, const char *input, size_t length) noexcept
Definition ada_c.cpp:331
bool ada_search_params_has(ada_url_search_params result, const char *key, size_t key_length)
Definition ada_c.cpp:565
bool ada_has_non_empty_username(ada_url result) noexcept
Definition ada_c.cpp:395
void ada_search_params_reset(ada_url_search_params result, const char *input, size_t length)
Definition ada_c.cpp:514
void ada_search_params_remove(ada_url_search_params result, const char *key, size_t key_length)
Definition ada_c.cpp:545
void ada_clear_search(ada_url result) noexcept
Definition ada_c.cpp:364
ada_string ada_get_username(ada_url result) noexcept
Definition ada_c.cpp:144
void * ada_url_search_params_entries_iter
Definition ada_c.h:136
void * ada_strings
Definition ada_c.h:127
void * ada_url_search_params
Definition ada_c.h:124
void * ada_url
Definition ada_c.h:47
void * ada_url_search_params_keys_iter
Definition ada_c.h:128
void * ada_url_search_params_values_iter
Definition ada_c.h:129
#define ADA_VERSION
Definition ada_version.h:8
std::string to_ascii(std::string_view ut8_string)
std::string to_unicode(std::string_view input)
bool can_parse(std::string_view input, const std::string_view *base_input=nullptr)
url_search_params_iter< key_value_view_pair, url_search_params_iter_type::ENTRIES > url_search_params_entries_iter
void set_max_input_length(uint32_t length)
url_search_params_iter< std::string_view, url_search_params_iter_type::KEYS > url_search_params_keys_iter
uint32_t get_max_input_length()
url_search_params_iter< std::string_view, url_search_params_iter_type::VALUES > url_search_params_values_iter
tl::expected< result_type, ada::errors > result
@ ADA_VERSION_MINOR
Definition ada_version.h:14
@ ADA_VERSION_REVISION
Definition ada_version.h:15
@ ADA_VERSION_MAJOR
Definition ada_version.h:13
ada_warn_unused ada::result< result_type > parse(std::string_view input, const result_type *base_url=nullptr)
Stores byte offsets for URL components within a buffer.
Class for parsing and manipulating URL query strings.
ada::url_search_params_entries_iter iter
Definition ada_c.cpp:627
ada::url_search_params params
Definition ada_c.cpp:626
ada::url_search_params_keys_iter iter
Definition ada_c.cpp:617
ada::url_search_params params
Definition ada_c.cpp:616
ada::url_search_params_values_iter iter
Definition ada_c.cpp:622
ada::url_search_params params
Definition ada_c.cpp:621
size_t length
Definition ada_c.h:33
const char * data
Definition ada_c.h:32
ada_string value
Definition ada_c.h:133
ada_string key
Definition ada_c.h:132
const char * data
Definition ada_c.h:23
size_t length
Definition ada_c.h:24
uint32_t username_end
Definition ada_c.h:38
uint32_t host_end
Definition ada_c.h:40
uint32_t hash_start
Definition ada_c.h:44
uint32_t pathname_start
Definition ada_c.h:42
uint32_t port
Definition ada_c.h:41
uint32_t protocol_end
Definition ada_c.h:37
uint32_t search_start
Definition ada_c.h:43
uint32_t host_start
Definition ada_c.h:39
Inline functions for url aggregator.
Inline declarations for the URL Search Params.