Embedded Template Library 1.0
string_utilities.h
Go to the documentation of this file.
1
2
3/******************************************************************************
4The MIT License(MIT)
5
6Embedded Template Library.
7https://github.com/ETLCPP/etl
8https://www.etlcpp.com
9
10Copyright(c) 2020 John Wellbelove, John Lagerquist
11
12Permission is hereby granted, free of charge, to any person obtaining a copy
13of this software and associated documentation files(the "Software"), to deal
14in the Software without restriction, including without limitation the rights
15to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
16copies of the Software, and to permit persons to whom the Software is
17furnished to do so, subject to the following conditions :
18
19The above copyright notice and this permission notice shall be included in all
20copies or substantial portions of the Software.
21
22THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
25AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
28SOFTWARE.
29******************************************************************************/
30
31#ifndef ETL_STRING_UTILITIES_INCLUDED
32#define ETL_STRING_UTILITIES_INCLUDED
33
34#include "platform.h"
35#include "algorithm.h"
36#include "enum_type.h"
37#include "memory.h"
38#include "char_traits.h"
39#include "optional.h"
40
41#include <ctype.h>
42#include <stdint.h>
43
44#include "private/minmax_push.h"
45
46namespace etl
47{
48 //***************************************************************************
50 //***************************************************************************
52 {
53 enum enum_type
54 {
55 LEFT,
56 RIGHT,
57 };
58
59 ETL_DECLARE_ENUM_TYPE(string_pad_direction, int)
60 ETL_ENUM_TYPE(LEFT, "left")
61 ETL_ENUM_TYPE(RIGHT, "right")
62 ETL_END_ENUM_TYPE
63 };
64
65 //***************************************************************************
67 //***************************************************************************
68 template <typename TChar>
69 struct whitespace;
70
71 template <>
72 struct whitespace<char>
73 {
74 static ETL_CONSTEXPR const char* value()
75 {
76 return " \t\n\r\f\v";
77 }
78 };
79
80 template <>
81 struct whitespace<wchar_t>
82 {
83 static ETL_CONSTEXPR const wchar_t* value()
84 {
85 return L" \t\n\r\f\v";
86 }
87 };
88
89#if ETL_USING_CPP11
90 template <>
91 struct whitespace<char16_t>
92 {
93 static ETL_CONSTEXPR const char16_t* value()
94 {
95 return u" \t\n\r\f\v";
96 }
97 };
98
99 template <>
100 struct whitespace<char32_t>
101 {
102 static ETL_CONSTEXPR const char32_t* value()
103 {
104 return U" \t\n\r\f\v";
105 }
106 };
107#endif
108
109#if ETL_USING_CPP17
110 template <typename TChar>
111 inline constexpr const TChar* whitespace_v = whitespace<TChar>::value();
112#endif
113
114 //***************************************************************************
117 //***************************************************************************
118 template <typename TIString>
119 void trim_from_left(TIString& s, typename TIString::const_pointer trim_characters)
120 {
121 typename TIString::size_type position = s.find_first_not_of(trim_characters);
122 s.erase(0U, position);
123 }
124
125 //***************************************************************************
128 //***************************************************************************
129 template <typename TIString>
130 void trim_whitespace_left(TIString& s)
131 {
133 }
134
135 //***************************************************************************
138 //***************************************************************************
139 template <typename TStringView>
140 TStringView trim_from_view_left(const TStringView& view, typename TStringView::const_pointer trim_characters)
141 {
142 typename TStringView::size_type first = view.find_first_not_of(trim_characters);
143
144 typename TStringView::const_pointer pbegin = view.data() + view.size();
145
146 if (first != TStringView::npos)
147 {
148 pbegin = view.data() + first;
149 }
150
151 return TStringView(pbegin, etl::distance(pbegin, view.data() + view.size()));
152 }
153
154 //***************************************************************************
157 //***************************************************************************
158 template <typename TStringView>
159 TStringView trim_view_whitespace_left(TStringView& s)
160 {
162 }
163
164 //***************************************************************************
167 //***************************************************************************
168 template <typename TIString>
169 void trim_left(TIString& s, typename TIString::const_pointer delimiters)
170 {
171 typename TIString::size_type p = s.find_first_of(delimiters);
172
173 if (p == TIString::npos)
174 {
175 s.clear();
176 }
177 else
178 {
179 s.erase(0, p);
180 }
181 }
182
183 //***************************************************************************
186 //***************************************************************************
187 template <typename TStringView>
188 TStringView trim_view_left(const TStringView& view, typename TStringView::const_pointer delimiters)
189 {
190 typename TStringView::size_type first = view.find_first_of(delimiters);
191
192 typename TStringView::const_pointer pbegin = view.data();
193
194 if (first != TStringView::npos)
195 {
196 pbegin += first;
197 return TStringView(pbegin, view.size() - first);
198 }
199 else
200 {
201 return TStringView(pbegin, typename TStringView::size_type(0U));
202 }
203 }
204
205 //***************************************************************************
208 //***************************************************************************
209 template <typename TIString>
210 void trim_from_right(TIString& s, typename TIString::const_pointer trim_characters)
211 {
212 s.erase(s.find_last_not_of(trim_characters) + 1);
213 }
214
215 //***************************************************************************
218 //***************************************************************************
219 template <typename TIString>
220 void trim_whitespace_right(TIString& s)
221 {
223 }
224
225 //***************************************************************************
228 //***************************************************************************
229 template <typename TStringView>
230 TStringView trim_from_view_right(const TStringView& view, typename TStringView::const_pointer trim_characters)
231 {
232 typename TStringView::size_type last = view.find_last_not_of(trim_characters) + 1;
233
234 typename TStringView::const_pointer pend = view.data();
235
236 if (last != TStringView::npos)
237 {
238 pend += last;
239 }
240
241 return TStringView(view.data(), etl::distance(view.data(), pend));
242 }
243
244 //***************************************************************************
247 //***************************************************************************
248 template <typename TStringView>
249 TStringView trim_view_whitespace_right(TStringView& view)
250 {
252 }
253
254 //***************************************************************************
256 //***************************************************************************
257 template <typename TIString>
258 void trim_right(TIString& s, typename TIString::const_pointer delimiters)
259 {
260 typename TIString::size_type p = s.find_last_of(delimiters);
261
262 if (p == TIString::npos)
263 {
264 s.clear();
265 }
266 else
267 {
268 ++p;
269
270 if (p != s.size())
271 {
272 s.erase(p);
273 }
274 }
275 }
276
277 //***************************************************************************
279 //***************************************************************************
280 template <typename TStringView>
281 TStringView trim_view_right(const TStringView& view, typename TStringView::const_pointer delimiters)
282 {
283 typename TStringView::size_type last = view.find_last_of(delimiters) + 1;
284
285 typename TStringView::const_pointer pend = view.data();
286
287 if (last != TStringView::npos)
288 {
289 pend += last;
290 return TStringView(view.data(), etl::distance(view.data(), pend));
291 }
292 else
293 {
294 return TStringView(view.data(), typename TStringView::size_type(0U));
295 }
296 }
297
298 //***************************************************************************
301 //***************************************************************************
302 template <typename TIString>
303 void trim_from(TIString& s, typename TIString::const_pointer trim_characters)
304 {
305 trim_from_left(s, trim_characters);
306 trim_from_right(s, trim_characters);
307 }
308
309 //***************************************************************************
312 //***************************************************************************
313 template <typename TIString>
314 void trim_whitespace(TIString& s)
315 {
317 }
318
319 //***************************************************************************
322 //***************************************************************************
323 template <typename TStringView>
324 TStringView trim_from_view(const TStringView& view, typename TStringView::const_pointer trim_characters)
325 {
326 typename TStringView::size_type first = view.find_first_not_of(trim_characters);
327 typename TStringView::size_type last = view.find_last_not_of(trim_characters) + 1;
328
329 typename TStringView::const_pointer pbegin = view.data();
330 typename TStringView::const_pointer pend = view.data();
331
332 if (first != TStringView::npos)
333 {
334 pbegin += first;
335 }
336
337 if (last != TStringView::npos)
338 {
339 pend += last;
340 }
341
342 return TStringView(pbegin, etl::distance(pbegin, pend));
343 }
344
345 //***************************************************************************
348 //***************************************************************************
349 template <typename TStringView>
350 TStringView trim_view_whitespace(const TStringView& view)
351 {
353 }
354
355 //***************************************************************************
358 //***************************************************************************
359 template <typename TIString>
360 void trim(TIString& s, typename TIString::const_pointer delimiters)
361 {
362 trim_left(s, delimiters);
363 trim_right(s, delimiters);
364 }
365
366 //***************************************************************************
369 //***************************************************************************
370 template <typename TStringView>
371 TStringView trim_view(const TStringView& view, typename TStringView::const_pointer delimiters)
372 {
373 typename TStringView::size_type first = view.find_first_of(delimiters);
374 typename TStringView::size_type last = view.find_last_of(delimiters) + 1;
375
376 typename TStringView::const_pointer pbegin = view.data();
377 typename TStringView::const_pointer pend = view.data();
378
379 if (first != TStringView::npos)
380 {
381 pbegin += first;
382 }
383
384 if (last != TStringView::npos)
385 {
386 pend += last;
387 }
388
389 return TStringView(pbegin, etl::distance(pbegin, pend));
390 }
391
392 //***************************************************************************
394 //***************************************************************************
395 template <typename TIString>
396 void left_n(TIString& s, typename TIString::size_type n)
397 {
398 n = (n > s.size()) ? s.size() : n;
399
400 s.erase(s.begin() + n, s.end());
401 }
402
403 //***************************************************************************
405 //***************************************************************************
406 template <typename TStringView>
407 TStringView left_n_view(const TStringView& view, typename TStringView::size_type n)
408 {
409 n = (n > view.size()) ? view.size() : n;
410
411 return TStringView(etl::addressof(*view.begin()), n);
412 }
413
414 //***************************************************************************
416 //***************************************************************************
417 template <typename TIString>
418 void right_n(TIString& s, typename TIString::size_type n)
419 {
420 n = (n > s.size()) ? s.size() : n;
421
422 s.erase(s.begin(), s.end() - n);
423 }
424
425 //***************************************************************************
427 //***************************************************************************
428 template <typename TStringView>
429 TStringView right_n_view(const TStringView& view, typename TStringView::size_type n)
430 {
431 n = (n > view.size()) ? view.size() : n;
432
433 return TStringView(view.data() + view.size() - n, n);
434 }
435
436 //***************************************************************************
439 //***************************************************************************
440 template <typename TIString>
441 void reverse(TIString& s)
442 {
443 etl::reverse(s.begin(), s.end());
444 }
445
446 //***************************************************************************
448 //***************************************************************************
449 template <typename TIString, typename TPair>
450 void replace_characters(TIString& s,
451 const TPair* pairsbegin,
452 const TPair* pairsend)
453 {
454 while (pairsbegin != pairsend)
455 {
456 etl::replace(s.begin(), s.end(), pairsbegin->first, pairsbegin->second);
457 ++pairsbegin;
458 }
459 }
460
461 //***************************************************************************
463 //***************************************************************************
464 template <typename TIString, typename TPair>
465 void replace_strings(TIString& s,
466 const TPair* pairsbegin,
467 const TPair* pairsend)
468 {
469 while (pairsbegin != pairsend)
470 {
471 const typename TIString::value_type* p_old = pairsbegin->first;
472 const typename TIString::value_type* p_new = pairsbegin->second;
473
474 typename TIString::size_type position = 0U;
475
476 do
477 {
478 position = s.find(p_old, position);
479 if (position != TIString::npos)
480 {
481 s.replace(position, typename TIString::size_type(etl::strlen(p_old)), p_new, typename TIString::size_type(etl::strlen(p_new)));
482 position += typename TIString::size_type(etl::strlen(p_new));
483 }
484 } while (position != TIString::npos);
485
486 ++pairsbegin;
487 }
488 }
489
490 //*********************************************************************
492 //*********************************************************************
493 template <typename TIterator, typename TPointer>
494 TIterator find_first_of(TIterator first, TIterator last, TPointer delimiters)
495 {
496 TIterator itr(first);
497
498 while (itr != last)
499 {
500 TPointer pd = delimiters;
501
502 while (*pd != 0)
503 {
504 if (*itr == *pd)
505 {
506 return itr;
507 }
508
509 ++pd;
510 }
511
512 ++itr;
513 }
514
515 return last;
516 }
517
518 //*********************************************************************
520 //*********************************************************************
521 template <typename TIString, typename TPointer>
522 typename TIString::iterator find_first_of(TIString& s, TPointer delimiters)
523 {
524 return find_first_of(s.begin(), s.end(), delimiters);
525 }
526
527 //*********************************************************************
529 //*********************************************************************
530 template <typename TIString, typename TPointer>
531 typename TIString::const_iterator find_first_of(const TIString& s, TPointer delimiters)
532 {
533 return find_first_of(s.begin(), s.end(), delimiters);
534 }
535
536 //*********************************************************************
538 //*********************************************************************
539 template <typename TIterator, typename TPointer>
540 TIterator find_first_not_of(TIterator first, TIterator last, TPointer delimiters)
541 {
542 TIterator itr(first);
543
544 while (itr != last)
545 {
546 TPointer pd = delimiters;
547
548 bool found = false;
549
550 while (*pd != 0)
551 {
552 if (*itr == *pd)
553 {
554 found = true;
555 break;
556 }
557
558 ++pd;
559 }
560
561 if (!found)
562 {
563 return itr;
564 }
565
566 ++itr;
567 }
568
569 return last;
570 }
571
572 //*********************************************************************
574 //*********************************************************************
575 template <typename TIString, typename TPointer>
576 typename TIString::iterator find_first_not_of(TIString& s, TPointer delimiters)
577 {
578 return find_first_not_of(s.begin(), s.end(), delimiters);
579 }
580
581 //*********************************************************************
583 //*********************************************************************
584 template <typename TIString, typename TPointer>
585 typename TIString::const_iterator find_first_not_of(const TIString& s, TPointer delimiters)
586 {
587 return find_first_not_of(s.begin(), s.end(), delimiters);
588 }
589
590 //*********************************************************************
592 //*********************************************************************
593 template <typename TIterator, typename TPointer>
594 TIterator find_last_of(TIterator first, TIterator last, TPointer delimiters)
595 {
596 if (first == last)
597 {
598 return last;
599 }
600
601 TIterator itr(last);
602 TIterator end(first);
603
604 do
605 {
606 --itr;
607
608 TPointer pd = delimiters;
609
610 while (*pd != 0)
611 {
612 if (*itr == *pd)
613 {
614 return itr;
615 }
616
617 ++pd;
618 }
619 } while (itr != end);
620
621 return last;
622 }
623
624 //*********************************************************************
626 //*********************************************************************
627 template <typename TIString, typename TPointer>
628 typename TIString::iterator find_last_of(TIString& s, TPointer delimiters)
629 {
630 return find_last_of(s.begin(), s.end(), delimiters);
631 }
632
633 //*********************************************************************
635 //*********************************************************************
636 template <typename TIString, typename TPointer>
637 typename TIString::const_iterator find_last_of(const TIString& s, TPointer delimiters)
638 {
639 return find_last_of(s.begin(), s.end(), delimiters);
640 }
641
642 //*********************************************************************
644 //*********************************************************************
645 template <typename TIterator, typename TPointer>
646 TIterator find_last_not_of(TIterator first, TIterator last, TPointer delimiters)
647 {
648 if (first == last)
649 {
650 return last;
651 }
652
653 TIterator itr(last);
654 TIterator end(first);
655
656 do
657 {
658 --itr;
659
660 TPointer pd = delimiters;
661
662 bool found = false;
663
664 while (*pd != 0)
665 {
666 if (*itr == *pd)
667 {
668 found = true;
669 break;
670 }
671
672 ++pd;
673 }
674
675 if (!found)
676 {
677 return itr;
678 }
679 } while (itr != end);
680
681 return last;
682 }
683
684 //*********************************************************************
686 //*********************************************************************
687 template <typename TIString, typename TPointer>
688 typename TIString::iterator find_last_not_of(TIString& s, TPointer delimiters)
689 {
690 return find_last_not_of(s.begin(), s.end(), delimiters);
691 }
692
693 //*********************************************************************
695 //*********************************************************************
696 template <typename TIString, typename TPointer>
697 typename TIString::const_iterator find_last_not_of(const TIString& s, TPointer delimiters)
698 {
699 return find_last_not_of(s.begin(), s.end(), delimiters);
700 }
701
702 //***************************************************************************
704 //***************************************************************************
705 template <typename TInput, typename TStringView>
706 etl::optional<TStringView> get_token(const TInput& input, typename TInput::const_pointer delimiters, const etl::optional<TStringView>& last_view, bool ignore_empty_tokens)
707 {
708 typedef typename TInput::const_pointer const_pointer;
709
710 bool token_found = false;
711 typename TStringView::size_type position = 0U;
712 TStringView view = last_view.value_or(TStringView());
713 const_pointer begin_ptr = input.data();
714
715 if (begin_ptr == ETL_NULLPTR)
716 {
718 }
719
720 const_pointer end_ptr = begin_ptr + input.size();
721
722 while (!token_found)
723 {
724 // Does the last view have valid data?
725 if (view.data() != ETL_NULLPTR)
726 {
727 position = etl::distance(begin_ptr, view.data() + view.size() + 1U);
728
729 // Have we reached the end of the string?
730 if (position > input.size())
731 {
733 }
734 }
735
736 // Look for the next token.
737 const_pointer first_ptr = begin_ptr + position;
738 const_pointer last_ptr = find_first_of(first_ptr, end_ptr, delimiters);
739
740 view = TStringView(first_ptr, etl::distance(first_ptr, last_ptr));
741
742 token_found = ((view.size() != 0U) || !ignore_empty_tokens);
743 }
744
745 return etl::optional<TStringView>(view);
746 }
747
748 //***************************************************************************
750 //***************************************************************************
751 template <typename TIString>
752 void pad_left(TIString& s, typename TIString::size_type required_size, typename TIString::value_type pad_char)
753 {
754 required_size = etl::min(required_size, s.max_size());
755
756 if (required_size > s.size())
757 {
758 required_size -= s.size();
759 s.insert(typename TIString::size_type(0U), required_size, pad_char);
760 }
761 }
762
763 //***************************************************************************
765 //***************************************************************************
766 template <typename TIString>
767 void pad_right(TIString& s, typename TIString::size_type required_size, typename TIString::value_type pad_char)
768 {
769 required_size = etl::min(required_size, s.max_size());
770
771 if (required_size > s.size())
772 {
773 required_size -= s.size();
774 s.insert(s.size(), required_size, pad_char);
775 }
776 }
777
778 //***************************************************************************
780 //***************************************************************************
781 template <typename TIString>
782 void pad(TIString& s, typename TIString::size_type required_size, string_pad_direction pad_direction, typename TIString::value_type pad_char)
783 {
784 switch (int(pad_direction))
785 {
786 case string_pad_direction::LEFT:
787 {
788 pad_left(s, required_size, pad_char);
789 break;
790 }
791
792 case string_pad_direction::RIGHT:
793 {
794 pad_right(s, required_size, pad_char);
795 break;
796 }
797
798 default:
799 {
800 break;
801 }
802 }
803 }
804
805 //***************************************************************************
807 //***************************************************************************
808 template <typename TString>
809 void to_upper_case(TString& s)
810 {
811 etl::transform(s.begin(), s.end(), s.begin(), ::toupper);
812 }
813
814 //***************************************************************************
816 //***************************************************************************
817 template <typename TString>
818 void to_lower_case(TString& s)
819 {
820 etl::transform(s.begin(), s.end(), s.begin(), ::tolower);
821 }
822
823 //***************************************************************************
825 //***************************************************************************
826 template <typename TString>
827 void to_sentence_case(TString& s)
828 {
829 typename TString::iterator itr = s.begin();
830
831 *itr = typename TString::value_type(::toupper(*itr));
832 ++itr;
833
834 etl::transform(itr, s.end(), itr, ::tolower);
835 }
836}
837
838#include "private/minmax_pop.h"
839
840#endif
Definition: optional.h:108
ETL_CONSTEXPR17 T * addressof(T &t)
Definition: addressof.h:51
bitset_ext
Definition: absolute.h:38
TIterator find_first_not_of(TIterator first, TIterator last, TPointer delimiters)
Find first not of any of delimiters within the string.
Definition: string_utilities.h:540
void trim_from_left(TIString &s, typename TIString::const_pointer trim_characters)
Definition: string_utilities.h:119
TStringView trim_from_view_right(const TStringView &view, typename TStringView::const_pointer trim_characters)
Definition: string_utilities.h:230
void trim(TIString &s, typename TIString::const_pointer delimiters)
Definition: string_utilities.h:360
TIterator find_first_of(TIterator first, TIterator last, TPointer delimiters)
Find first of any of delimiters within the string.
Definition: string_utilities.h:494
void to_lower_case(TString &s)
to_lower_case
Definition: string_utilities.h:818
void trim_whitespace_right(TIString &s)
Definition: string_utilities.h:220
void pad_right(TIString &s, typename TIString::size_type required_size, typename TIString::value_type pad_char)
pad_right
Definition: string_utilities.h:767
void pad(TIString &s, typename TIString::size_type required_size, string_pad_direction pad_direction, typename TIString::value_type pad_char)
pad
Definition: string_utilities.h:782
void right_n(TIString &s, typename TIString::size_type n)
Get up to the last n characters.
Definition: string_utilities.h:418
void trim_left(TIString &s, typename TIString::const_pointer delimiters)
Definition: string_utilities.h:169
TStringView left_n_view(const TStringView &view, typename TStringView::size_type n)
Get a view of up to the first n characters.
Definition: string_utilities.h:407
void replace_characters(TIString &s, const TPair *pairsbegin, const TPair *pairsend)
replace_characters
Definition: string_utilities.h:450
void to_sentence_case(TString &s)
to_sentence_case
Definition: string_utilities.h:827
TIterator find_last_of(TIterator first, TIterator last, TPointer delimiters)
Find last of any of delimiters within the string.
Definition: string_utilities.h:594
void trim_from_right(TIString &s, typename TIString::const_pointer trim_characters)
Definition: string_utilities.h:210
TStringView trim_view(const TStringView &view, typename TStringView::const_pointer delimiters)
Definition: string_utilities.h:371
TStringView trim_view_whitespace(const TStringView &view)
Definition: string_utilities.h:350
TStringView trim_view_left(const TStringView &view, typename TStringView::const_pointer delimiters)
Definition: string_utilities.h:188
void trim_right(TIString &s, typename TIString::const_pointer delimiters)
trim_right
Definition: string_utilities.h:258
TStringView trim_view_whitespace_right(TStringView &view)
Definition: string_utilities.h:249
TStringView trim_from_view(const TStringView &view, typename TStringView::const_pointer trim_characters)
Definition: string_utilities.h:324
void trim_whitespace_left(TIString &s)
Definition: string_utilities.h:130
void pad_left(TIString &s, typename TIString::size_type required_size, typename TIString::value_type pad_char)
pad_left
Definition: string_utilities.h:752
TStringView trim_view_whitespace_left(TStringView &s)
Definition: string_utilities.h:159
etl::optional< TStringView > get_token(const TInput &input, typename TInput::const_pointer delimiters, const etl::optional< TStringView > &last_view, bool ignore_empty_tokens)
get_token
Definition: string_utilities.h:706
TIterator find_last_not_of(TIterator first, TIterator last, TPointer delimiters)
Find last not of any of delimiters within the string.
Definition: string_utilities.h:646
void left_n(TIString &s, typename TIString::size_type n)
Get up to the first n characters.
Definition: string_utilities.h:396
void to_upper_case(TString &s)
to_upper_case
Definition: string_utilities.h:809
void trim_whitespace(TIString &s)
Definition: string_utilities.h:314
TStringView right_n_view(const TStringView &view, typename TStringView::size_type n)
Get a view of up to the last n characters.
Definition: string_utilities.h:429
void trim_from(TIString &s, typename TIString::const_pointer trim_characters)
Definition: string_utilities.h:303
TStringView trim_from_view_left(const TStringView &view, typename TStringView::const_pointer trim_characters)
Definition: string_utilities.h:140
void replace_strings(TIString &s, const TPair *pairsbegin, const TPair *pairsend)
replace_strings
Definition: string_utilities.h:465
ETL_CONSTEXPR size_t strlen(const T *t)
Alternative strlen for all character types.
Definition: char_traits.h:267
TStringView trim_view_right(const TStringView &view, typename TStringView::const_pointer delimiters)
trim_view_right
Definition: string_utilities.h:281
ETL_CONSTEXPR TContainer::iterator end(TContainer &container)
Definition: iterator.h:961
string_pad_direction
Definition: string_utilities.h:52
whitespace
Definition: string_utilities.h:69