Ada 3.2.1
Fast spec-compliant URL parser
Loading...
Searching...
No Matches
url_search_params-inl.h
Go to the documentation of this file.
1
5#ifndef ADA_URL_SEARCH_PARAMS_INL_H
6#define ADA_URL_SEARCH_PARAMS_INL_H
7
9#include "ada/unicode.h"
11
12#include <algorithm>
13#include <optional>
14#include <ranges>
15#include <string>
16#include <string_view>
17#include <vector>
18
19namespace ada {
20
21// A default, empty url_search_params for use with empty iterators.
22template <typename T, ada::url_search_params_iter_type Type>
23url_search_params url_search_params_iter<T, Type>::EMPTY;
24
25inline void url_search_params::reset(std::string_view input) {
26 params.clear();
27 initialize(input);
28}
29
30inline void url_search_params::initialize(std::string_view input) {
31 if (!input.empty() && input.front() == '?') {
32 input.remove_prefix(1);
33 }
34
35 auto process_key_value = [&](const std::string_view current) {
36 auto equal = current.find('=');
37
38 if (equal == std::string_view::npos) {
39 std::string name(current);
40 std::ranges::replace(name, '+', ' ');
41 params.emplace_back(unicode::percent_decode(name, name.find('%')), "");
42 } else {
43 std::string name(current.substr(0, equal));
44 std::string value(current.substr(equal + 1));
45
46 std::ranges::replace(name, '+', ' ');
47 std::ranges::replace(value, '+', ' ');
48
49 params.emplace_back(unicode::percent_decode(name, name.find('%')),
50 unicode::percent_decode(value, value.find('%')));
51 }
52 };
53
54 while (!input.empty()) {
55 auto ampersand_index = input.find('&');
56
57 if (ampersand_index == std::string_view::npos) {
58 if (!input.empty()) {
59 process_key_value(input);
60 }
61 break;
62 } else if (ampersand_index != 0) {
63 process_key_value(input.substr(0, ampersand_index));
64 }
65
66 input.remove_prefix(ampersand_index + 1);
67 }
68}
69
70inline void url_search_params::append(const std::string_view key,
71 const std::string_view value) {
72 params.emplace_back(key, value);
73}
74
75inline size_t url_search_params::size() const noexcept { return params.size(); }
76
77inline std::optional<std::string_view> url_search_params::get(
78 const std::string_view key) {
79 auto entry = std::ranges::find_if(
80 params, [&key](const auto &param) { return param.first == key; });
81
82 if (entry == params.end()) {
83 return std::nullopt;
84 }
85
86 return entry->second;
87}
88
89inline std::vector<std::string> url_search_params::get_all(
90 const std::string_view key) {
91 std::vector<std::string> out{};
92
93 for (auto &param : params) {
94 if (param.first == key) {
95 out.emplace_back(param.second);
96 }
97 }
98
99 return out;
100}
101
102inline bool url_search_params::has(const std::string_view key) noexcept {
103 auto entry = std::ranges::find_if(
104 params, [&key](const auto &param) { return param.first == key; });
105 return entry != params.end();
106}
107
108inline bool url_search_params::has(std::string_view key,
109 std::string_view value) noexcept {
110 auto entry = std::ranges::find_if(params, [&key, &value](const auto &param) {
111 return param.first == key && param.second == value;
112 });
113 return entry != params.end();
114}
115
116inline std::string url_search_params::to_string() const {
118 std::string out{};
119 for (size_t i = 0; i < params.size(); i++) {
120 auto key = ada::unicode::percent_encode(params[i].first, character_set);
121 auto value = ada::unicode::percent_encode(params[i].second, character_set);
122
123 // Performance optimization: Move this inside percent_encode.
124 std::ranges::replace(key, ' ', '+');
125 std::ranges::replace(value, ' ', '+');
126
127 if (i != 0) {
128 out += "&";
129 }
130 out.append(key);
131 out += "=";
132 out.append(value);
133 }
134 return out;
135}
136
137inline void url_search_params::set(const std::string_view key,
138 const std::string_view value) {
139 const auto find = [&key](const auto &param) { return param.first == key; };
140
141 auto it = std::ranges::find_if(params, find);
142
143 if (it == params.end()) {
144 params.emplace_back(key, value);
145 } else {
146 it->second = value;
147 params.erase(std::remove_if(std::next(it), params.end(), find),
148 params.end());
149 }
150}
151
152inline void url_search_params::remove(const std::string_view key) {
153 std::erase_if(params,
154 [&key](const auto &param) { return param.first == key; });
155}
156
157inline void url_search_params::remove(const std::string_view key,
158 const std::string_view value) {
159 std::erase_if(params, [&key, &value](const auto &param) {
160 return param.first == key && param.second == value;
161 });
162}
163
165 // We rely on the fact that the content is valid UTF-8.
166 std::ranges::stable_sort(params, [](const key_value_pair &lhs,
167 const key_value_pair &rhs) {
168 size_t i = 0, j = 0;
169 uint32_t low_surrogate1 = 0, low_surrogate2 = 0;
170 while ((i < lhs.first.size() || low_surrogate1 != 0) &&
171 (j < rhs.first.size() || low_surrogate2 != 0)) {
172 uint32_t codePoint1 = 0, codePoint2 = 0;
173
174 if (low_surrogate1 != 0) {
175 codePoint1 = low_surrogate1;
176 low_surrogate1 = 0;
177 } else {
178 uint8_t c1 = uint8_t(lhs.first[i]);
179 if (c1 <= 0x7F) {
180 codePoint1 = c1;
181 i++;
182 } else if (c1 <= 0xDF) {
183 codePoint1 = ((c1 & 0x1F) << 6) | (uint8_t(lhs.first[i + 1]) & 0x3F);
184 i += 2;
185 } else if (c1 <= 0xEF) {
186 codePoint1 = ((c1 & 0x0F) << 12) |
187 ((uint8_t(lhs.first[i + 1]) & 0x3F) << 6) |
188 (uint8_t(lhs.first[i + 2]) & 0x3F);
189 i += 3;
190 } else {
191 codePoint1 = ((c1 & 0x07) << 18) |
192 ((uint8_t(lhs.first[i + 1]) & 0x3F) << 12) |
193 ((uint8_t(lhs.first[i + 2]) & 0x3F) << 6) |
194 (uint8_t(lhs.first[i + 3]) & 0x3F);
195 i += 4;
196
197 codePoint1 -= 0x10000;
198 uint16_t high_surrogate = uint16_t(0xD800 + (codePoint1 >> 10));
199 low_surrogate1 = uint16_t(0xDC00 + (codePoint1 & 0x3FF));
200 codePoint1 = high_surrogate;
201 }
202 }
203
204 if (low_surrogate2 != 0) {
205 codePoint2 = low_surrogate2;
206 low_surrogate2 = 0;
207 } else {
208 uint8_t c2 = uint8_t(rhs.first[j]);
209 if (c2 <= 0x7F) {
210 codePoint2 = c2;
211 j++;
212 } else if (c2 <= 0xDF) {
213 codePoint2 = ((c2 & 0x1F) << 6) | (uint8_t(rhs.first[j + 1]) & 0x3F);
214 j += 2;
215 } else if (c2 <= 0xEF) {
216 codePoint2 = ((c2 & 0x0F) << 12) |
217 ((uint8_t(rhs.first[j + 1]) & 0x3F) << 6) |
218 (uint8_t(rhs.first[j + 2]) & 0x3F);
219 j += 3;
220 } else {
221 codePoint2 = ((c2 & 0x07) << 18) |
222 ((uint8_t(rhs.first[j + 1]) & 0x3F) << 12) |
223 ((uint8_t(rhs.first[j + 2]) & 0x3F) << 6) |
224 (uint8_t(rhs.first[j + 3]) & 0x3F);
225 j += 4;
226 codePoint2 -= 0x10000;
227 uint16_t high_surrogate = uint16_t(0xD800 + (codePoint2 >> 10));
228 low_surrogate2 = uint16_t(0xDC00 + (codePoint2 & 0x3FF));
229 codePoint2 = high_surrogate;
230 }
231 }
232
233 if (codePoint1 != codePoint2) {
234 return (codePoint1 < codePoint2);
235 }
236 }
237 return (j < rhs.first.size() || low_surrogate2 != 0);
238 });
239}
240
244
251
258
259template <typename T, url_search_params_iter_type Type>
261 return pos < params.params.size();
262}
263
264template <>
265inline std::optional<std::string_view> url_search_params_keys_iter::next() {
266 if (!has_next()) {
267 return std::nullopt;
268 }
269 return params.params[pos++].first;
270}
271
272template <>
273inline std::optional<std::string_view> url_search_params_values_iter::next() {
274 if (!has_next()) {
275 return std::nullopt;
276 }
277 return params.params[pos++].second;
278}
279
280template <>
281inline std::optional<key_value_view_pair>
283 if (!has_next()) {
284 return std::nullopt;
285 }
286 return params.params[pos++];
287}
288
289} // namespace ada
290
291#endif // ADA_URL_SEARCH_PARAMS_INL_H
Definitions of the character sets used by unicode functions.
constexpr uint8_t WWW_FORM_URLENCODED_PERCENT_ENCODE[32]
Definition ada_idna.h:13
url_search_params_iter< std::string_view, url_search_params_iter_type::VALUES > url_search_params_values_iter
url_search_params_iter< key_value_view_pair, url_search_params_iter_type::ENTRIES > url_search_params_entries_iter
url_search_params_iter< std::string_view, url_search_params_iter_type::KEYS > url_search_params_keys_iter
void set(std::string_view key, std::string_view value)
std::vector< std::string > get_all(std::string_view key)
void remove(std::string_view key)
url_search_params_entries_iter get_entries()
std::string to_string() const
url_search_params_keys_iter get_keys()
size_t size() const noexcept
void append(std::string_view key, std::string_view value)
url_search_params_values_iter get_values()
std::optional< std::string_view > get(std::string_view key)
bool has(std::string_view key) noexcept
Definitions for all unicode specific functions.
Declaration for the URL Search Params.