rustils/impls/
str_impl.rs1use string;
2
3impl string::StringUtils for &'static str {
4
5 fn adv_contains_all_chars(&self, search: &[char])
6 -> (bool, Vec<usize>, Vec<char>) {
7
8 string::adv_contains_all_chars(&self.to_string(), search)
9 }
10
11 fn adv_contains_all_strs(&self, search: &[&str])
12 -> (bool, Vec<usize>, Vec<String>) {
13
14 string::adv_contains_all_strs(&self.to_string(), search)
15 }
16
17 fn adv_contains_any_char(&self, search: &[char])
18 -> (bool, usize, char) {
19
20 string::adv_contains_any_char(&self.to_string(), search)
21 }
22
23 fn adv_contains_any_str(&self, search: &[&str])
24 -> (bool, usize, String) {
25
26 string::adv_contains_any_str(&self.to_string(), search)
27 }
28
29 fn adv_contains_none_char(&self, search: &[char])
30 -> (bool, usize, char) {
31
32 string::adv_contains_none_char(&self.to_string(), search)
33 }
34
35 fn adv_contains_none_str(&self, search: &[&str])
36 -> (bool, usize, String) {
37
38 string::adv_contains_none_str(&self.to_string(), search)
39 }
40
41 fn adv_ends_with(&self, search: &str)
42 -> (bool, String) {
43
44 string::adv_ends_with(&self.to_string(), search)
45 }
46
47 fn adv_has_alpha(&self)
48 -> (bool, Vec<bool>) {
49
50 string::adv_has_alpha(&self.to_string())
51 }
52
53 fn adv_has_alphanumeric(&self)
54 -> (bool, Vec<bool>) {
55
56 string::adv_has_alphanumeric(&self.to_string())
57 }
58
59 fn adv_has_alphanumeric_space(&self)
60 -> (bool, Vec<bool>) {
61
62 string::adv_has_alphanumeric_space(&self.to_string())
63 }
64
65 fn adv_has_alpha_space(&self)
66 -> (bool, Vec<bool>) {
67
68 string::adv_has_alpha_space(&self.to_string())
69 }
70
71 fn adv_has_lowercase(&self)
72 -> (bool, Vec<bool>) {
73
74 string::adv_has_lowercase(&self.to_string())
75 }
76
77 fn adv_has_numeric(&self)
78 -> (bool, Vec<bool>) {
79
80 string::adv_has_numeric(&self.to_string())
81 }
82
83 fn adv_has_numeric_space(&self)
84 -> (bool, Vec<bool>) {
85
86 string::adv_has_numeric_space(&self.to_string())
87 }
88
89 fn adv_has_uppercase(&self)
90 -> (bool, Vec<bool>) {
91
92 string::adv_has_uppercase(&self.to_string())
93 }
94
95 fn adv_has_whitespace(&self)
96 -> (bool, Vec<bool>) {
97
98 string::adv_has_whitespace(&self.to_string())
99 }
100
101 fn adv_is_alpha(&self)
102 -> (bool, Vec<bool>) {
103
104 string::adv_is_alpha(&self.to_string())
105 }
106
107 fn adv_is_alphanumeric(&self)
108 -> (bool, Vec<bool>) {
109
110 string::adv_is_alphanumeric(&self.to_string())
111 }
112
113 fn adv_is_alphanumeric_space(&self)
114 -> (bool, Vec<bool>) {
115
116 string::adv_is_alphanumeric_space(&self.to_string())
117 }
118
119 fn adv_is_alpha_space(&self)
120 -> (bool, Vec<bool>) {
121
122 string::adv_is_alpha_space(&self.to_string())
123 }
124
125 fn adv_is_lowercase(&self)
126 -> (bool, Vec<bool>) {
127
128 string::adv_is_lowercase(&self.to_string())
129 }
130
131 fn adv_is_numeric(&self)
132 -> (bool, Vec<bool>) {
133
134 string::adv_is_numeric(&self.to_string())
135 }
136
137 fn adv_is_numeric_space(&self)
138 -> (bool, Vec<bool>) {
139
140 string::adv_is_numeric_space(&self.to_string())
141 }
142
143 fn adv_is_uppercase(&self)
144 -> (bool, Vec<bool>) {
145
146 string::adv_is_uppercase(&self.to_string())
147 }
148
149 fn adv_is_whitespace(&self)
150 -> (bool, Vec<bool>) {
151
152 string::adv_is_whitespace(&self.to_string())
153 }
154
155 fn adv_remove_all_regex(&self, regex: &str)
156 -> (bool, Vec<(usize, usize)>, String) {
157
158 string::adv_remove_all_regex(&self.to_string(), regex)
159 }
160
161 fn adv_remove_regex(&self, regex: &str)
162 -> (bool, usize, String) {
163
164 string::adv_remove_regex(&self.to_string(), regex)
165 }
166
167 fn adv_starts_with(&self, search: &str)
168 -> (bool, String) {
169
170 string::adv_starts_with(&self.to_string(), search)
171 }
172
173 fn contains_all_chars(&self, search: &[char])
174 -> bool {
175
176 string::contains_all_chars(&self.to_string(), search)
177 }
178
179 fn contains_all_strs(&self, search: &[&str])
180 -> bool {
181
182 string::contains_all_strs(&self.to_string(), search)
183 }
184
185 fn contains_any_char(&self, search: &[char])
186 -> bool {
187
188 string::contains_any_char(&self.to_string(), search)
189 }
190
191 fn contains_any_str(&self, search: &[&str])
192 -> bool {
193
194 string::contains_any_str(&self.to_string(), search)
195 }
196
197 fn contains_none_char(&self, search: &[char])
198 -> bool {
199
200 string::contains_none_char(&self.to_string(), search)
201 }
202
203 fn contains_none_str(&self, search: &[&str])
204 -> bool {
205
206 string::contains_none_str(&self.to_string(), search)
207 }
208
209 fn cmp_ignore_case(&self, cmp: &str)
210 -> bool {
211
212 string::cmp_ignore_case(&self.to_string(), cmp)
213 }
214
215 fn difference(&self, diff: &str)
216 -> Vec<usize> {
217
218 string::difference(&self.to_string(), diff)
219 }
220
221 fn find_char(&self, search: char)
222 -> usize {
223
224 string::find_char(&self.to_string(), search)
225 }
226
227 fn find_char_opt(&self, search: char)
228 -> Option<usize> {
229
230 string::find_char_opt(&self.to_string(), search)
231 }
232
233 fn has_alpha(&self)
234 -> bool {
235
236 string::has_alpha(&self.to_string())
237 }
238
239 fn has_alphanumeric(&self)
240 -> bool {
241
242 string::has_alphanumeric(&self.to_string())
243 }
244
245 fn has_alphanumeric_space(&self)
246 -> bool {
247
248 string::has_alphanumeric_space(&self.to_string())
249 }
250
251 fn has_alpha_space(&self)
252 -> bool {
253
254 string::has_alpha_space(&self.to_string())
255 }
256
257 fn has_lowercase(&self)
258 -> bool {
259
260 string::has_lowercase(&self.to_string())
261 }
262
263 fn has_numeric(&self)
264 -> bool {
265
266 string::has_numeric(&self.to_string())
267 }
268
269 fn has_numeric_space(&self)
270 -> bool {
271
272 string::has_numeric_space(&self.to_string())
273 }
274
275 fn has_uppercase(&self)
276 -> bool {
277
278 string::has_uppercase(&self.to_string())
279 }
280
281 fn has_whitespace(&self)
282 -> bool {
283
284 string::has_whitespace(&self.to_string())
285 }
286
287 fn is_alpha(&self)
288 -> bool {
289
290 string::is_alpha(&self.to_string())
291 }
292
293 fn is_alphanumeric(&self)
294 -> bool {
295
296 string::is_alphanumeric(&self.to_string())
297 }
298
299 fn is_alphanumeric_space(&self)
300 -> bool {
301
302 string::is_alphanumeric_space(&self.to_string())
303 }
304
305 fn is_alpha_space(&self)
306 -> bool {
307
308 string::is_alpha_space(&self.to_string())
309 }
310
311 fn is_lowercase(&self)
312 -> bool {
313
314 string::is_lowercase(&self.to_string())
315 }
316
317 fn is_numeric(&self)
318 -> bool {
319
320 string::is_numeric(&self.to_string())
321 }
322
323 fn is_numeric_space(&self)
324 -> bool {
325
326 string::is_numeric_space(&self.to_string())
327 }
328
329 fn is_uppercase(&self)
330 -> bool {
331
332 string::is_uppercase(&self.to_string())
333 }
334
335 fn is_whitespace(&self)
336 -> bool {
337
338 string::is_whitespace(&self.to_string())
339 }
340
341 fn peek(&self)
342 -> char {
343
344 string::peek(&self.to_string())
345 }
346
347 fn peek_opt(&self)
348 -> Option<char> {
349
350 string::peek_opt(&self.to_string())
351 }
352
353 fn remove_all_regex(&self, regex: &str)
354 -> String {
355
356 string::remove_all_regex(&self.to_string(), regex)
357 }
358
359 fn remove_all_regex_mut(&mut self, _regex: &str)
360 -> bool {
361
362 unimplemented!()
363 }
364
365 fn remove_regex(&self, regex: &str)
366 -> String {
367
368 string::remove_regex(&self.to_string(), regex)
369 }
370
371 fn remove_regex_mut(&mut self, _regex: &str)
372 -> bool {
373
374 unimplemented!()
375 }
376
377 fn reverse(&self)
378 -> String {
379
380 string::reverse(&self.to_string())
381 }
382
383 fn reverse_mut(&mut self) {
384
385 unimplemented!()
386 }
387
388 fn reverse_str(&self)
389 -> &'static str {
390
391 string::reverse_str(&self.to_string())
392 }
393}