libfilezilla
Loading...
Searching...
No Matches
string.hpp
Go to the documentation of this file.
1#ifndef LIBFILEZILLA_STRING_HEADER
2#define LIBFILEZILLA_STRING_HEADER
3
4#include "libfilezilla.hpp"
5
6#include <algorithm>
7#include <cstdint>
8#include <limits>
9#include <optional>
10#include <string>
11#include <string_view>
12#include <vector>
13
14template<class CharT, class BaseT>
16{
17public:
18 using char_type = CharT;
19
20 using base_type = BaseT;
21 using base_traits = std::char_traits<base_type>;
22
23 static std::size_t length(char_type const* s) {
24 return base_traits::length(reinterpret_cast<base_type const*>(s));
25 }
26 static int compare(char_type const* s1, char_type const* s2, std::size_t count) {
27 return base_traits::compare(reinterpret_cast<base_type const*>(s1), reinterpret_cast<base_type const*>(s2), count);
28 }
29 static char_type* copy(char_type* dest, char_type const* src, std::size_t count) {
30 return reinterpret_cast<char_type*>(base_traits::copy(reinterpret_cast<base_type*>(dest), reinterpret_cast<base_type const*>(src), count));
31 }
32 static void assign( char_type& c1, char_type const& c2 ) noexcept {
33 c1 = c2;
34 }
35 static char_type const* find(char_type const* ptr, std::size_t count, char_type const& ch) {
36 return reinterpret_cast<char_type const*>(base_traits::find(reinterpret_cast<base_type const*>(ptr), count, reinterpret_cast<base_type const&>(ch)));
37 }
38 static bool eq(char_type a, char_type b) {
39 return base_traits::eq(static_cast<base_type>(a), static_cast<base_type>(b));
40 }
41};
42
43template<>
44class std::char_traits<uint8_t> : public traits_cloner<uint8_t, char>
45{};
46
53
54namespace fz {
55
67
68#ifdef FZ_WINDOWS
69typedef std::wstring native_string;
70typedef std::wstring_view native_string_view;
71#endif
72#if defined(FZ_UNIX) || defined(FZ_MAC)
73typedef std::string native_string;
74typedef std::string_view native_string_view;
75#endif
76
81native_string FZ_PUBLIC_SYMBOL to_native(std::string_view const& in);
82
87native_string FZ_PUBLIC_SYMBOL to_native(std::wstring_view const& in);
88
90template<typename T, typename std::enable_if_t<std::is_same_v<native_string, typename std::decay_t<T>>, int> = 0>
91inline native_string to_native(T const& in) {
92 return in;
93}
94
101int FZ_PUBLIC_SYMBOL stricmp(std::string_view const& a, std::string_view const& b);
102int FZ_PUBLIC_SYMBOL stricmp(std::wstring_view const& a, std::wstring_view const& b);
103
121template<typename Char>
122Char tolower_ascii(Char c) {
123 if (c >= 'A' && c <= 'Z') {
124 return c + ('a' - 'A');
125 }
126 return c;
127}
128
129template<>
130std::wstring::value_type FZ_PUBLIC_SYMBOL tolower_ascii(std::wstring::value_type c);
131
133template<typename Char>
134Char toupper_ascii(Char c) {
135 if (c >= 'a' && c <= 'z') {
136 return c + ('A' - 'a');
137 }
138 return c;
139}
140
141template<>
142std::wstring::value_type FZ_PUBLIC_SYMBOL toupper_ascii(std::wstring::value_type c);
143
146 // Note: For UTF-8 strings it works on individual octets!
147std::string FZ_PUBLIC_SYMBOL str_tolower_ascii(std::string_view const& s);
148std::wstring FZ_PUBLIC_SYMBOL str_tolower_ascii(std::wstring_view const& s);
149
150std::string FZ_PUBLIC_SYMBOL str_toupper_ascii(std::string_view const& s);
151std::wstring FZ_PUBLIC_SYMBOL str_toupper_ascii(std::wstring_view const& s);
152
155template<typename T, typename = void>
157
158template<typename T>
159struct string_value_type<T, std::void_t<typename T::value_type>> {
160 using type = typename T::value_type;
161};
162
163template<typename CharT>
164struct string_value_type<CharT*> {
165 using type = std::remove_cv_t<CharT>;
166};
167
168template<typename CharT, std::size_t N>
169struct string_value_type<CharT (&)[N]> {
170 using type = std::remove_cv_t<CharT>;
171};
172
173template<typename CharT, std::size_t N>
174struct string_value_type<CharT[N]> {
175 using type = std::remove_cv_t<CharT>;
176};
177
178// Helper alias for easier use.
179template<typename T>
180using string_value_type_t = typename string_value_type<T>::type;
181
187struct FZ_PUBLIC_SYMBOL less_insensitive_ascii final
188{
189 using is_transparent = std::true_type;
190
191 template<typename L, typename R,
192 std::enable_if_t<std::is_same_v<string_value_type_t<L>, string_value_type_t<R>>>* = nullptr>
193 bool operator()(L const& lhs, R const& rhs) const {
194 std::basic_string_view<string_value_type_t<L>> lv(lhs);
195 std::basic_string_view<string_value_type_t<R>> rv(rhs);
196
197 return std::lexicographical_compare(lv.begin(), lv.end(), rv.begin(), rv.end(),
198 [](auto const& a, auto const& b) {
199 return tolower_ascii(a) < tolower_ascii(b);
200 }
201 );
202 }
203};
204
209template<typename A, typename B,
210 std::enable_if_t<std::is_same_v<string_value_type_t<A>, string_value_type_t<B>>>* = nullptr>
211inline bool equal_insensitive_ascii(A const& a, B const& b)
212{
213 std::basic_string_view<string_value_type_t<A>> av(a);
214 std::basic_string_view<string_value_type_t<B>> bv(b);
215
216 return std::equal(av.cbegin(), av.cend(), bv.cbegin(), bv.cend(),
217 [](auto const& a, auto const& b) {
218 return tolower_ascii(a) == tolower_ascii(b);
219 }
220 );
221}
222
227std::wstring FZ_PUBLIC_SYMBOL to_wstring(std::string_view const& in);
228
233template <typename T>
234inline auto to_wstring(T && in) -> decltype(std::wstring(std::forward<T>(in)))
235{
236 return std::wstring(std::forward<T>(in));
237}
238
240template<typename Arg>
241inline typename std::enable_if<std::is_arithmetic_v<std::decay_t<Arg>>, std::wstring>::type to_wstring(Arg && arg)
242{
243 return std::to_wstring(std::forward<Arg>(arg));
244}
245
246
251std::wstring FZ_PUBLIC_SYMBOL to_wstring_from_utf8(std::string_view const& in);
252std::wstring FZ_PUBLIC_SYMBOL to_wstring_from_utf8(char const* s, size_t len);
253
254class buffer;
255std::wstring FZ_PUBLIC_SYMBOL to_wstring_from_utf8(fz::buffer const& in);
256
261std::string FZ_PUBLIC_SYMBOL to_string(std::wstring_view const& in);
262
267template <typename T>
268inline auto to_string(T && in) -> decltype(std::string(std::forward<T>(in)))
269{
270 return std::string(std::forward<T>(in));
271}
272
273
275template<typename Arg>
276inline typename std::enable_if<std::is_arithmetic_v<std::decay_t<Arg>>, std::string>::type to_string(Arg && arg)
277{
278 return std::to_string(std::forward<Arg>(arg));
279}
280
281
283template<typename Char>
284size_t strlen(Char const* str) {
285 return std::char_traits<Char>::length(str);
286}
287
288
295std::string FZ_PUBLIC_SYMBOL to_utf8(std::string_view const& in);
296
303std::string FZ_PUBLIC_SYMBOL to_utf8(std::wstring_view const& in);
304
306template<typename String, typename Arg>
307inline auto toString(Arg&& arg) -> typename std::enable_if<std::is_same_v<String, std::string>, decltype(to_string(std::forward<Arg>(arg)))>::type
308{
309 return to_string(std::forward<Arg>(arg));
310}
311
312template<typename String, typename Arg>
313inline auto toString(Arg&& arg) -> typename std::enable_if<std::is_same_v<String, std::wstring>, decltype(to_wstring(std::forward<Arg>(arg)))>::type
314{
315 return to_wstring(std::forward<Arg>(arg));
316}
317
318#if !defined(fzT) || defined(DOXYGEN)
319#ifdef FZ_WINDOWS
324#define fzT(x) L ## x
325#else
330#define fzT(x) x
331#endif
332#endif
333
335template<typename Char>
336constexpr Char const* choose_string(char const* c, wchar_t const* w);
337
338template<> constexpr inline char const* choose_string(char const* c, wchar_t const*) { return c; }
339template<> constexpr inline wchar_t const* choose_string(char const*, wchar_t const* w) { return w; }
340
341#if !defined(fzS) || defined(DOXYGEN)
353#define fzS(Char, s) fz::choose_string<Char>(s, L ## s)
354#endif
355
360std::string FZ_PUBLIC_SYMBOL replaced_substrings(std::string_view const& in, std::string_view const& find, std::string_view const& replacement);
361std::wstring FZ_PUBLIC_SYMBOL replaced_substrings(std::wstring_view const& in, std::wstring_view const& find, std::wstring_view const& replacement);
362
364std::string FZ_PUBLIC_SYMBOL replaced_substrings(std::string_view const& in, char find, char replacement);
365std::wstring FZ_PUBLIC_SYMBOL replaced_substrings(std::wstring_view const& in, wchar_t find, wchar_t replacement);
366
371bool FZ_PUBLIC_SYMBOL replace_substrings(std::string& in, std::string_view const& find, std::string_view const& replacement);
372bool FZ_PUBLIC_SYMBOL replace_substrings(std::wstring& in, std::wstring_view const& find, std::wstring_view const& replacement);
373
375bool FZ_PUBLIC_SYMBOL replace_substrings(std::string& in, char find, char replacement);
376bool FZ_PUBLIC_SYMBOL replace_substrings(std::wstring& in, wchar_t find, wchar_t replacement);
377
404template <typename String, typename Delims>
406{
407 using view_type = std::basic_string_view<std::decay_t<decltype(std::declval<String>()[0])>>;
408
409public:
416 constexpr strtokenizer(String && string, Delims &&delims, bool ignore_empty)
417 : string_(std::forward<String>(string))
418 , delims_(std::forward<Delims>(delims))
419 , ignore_empty_(ignore_empty)
420 {}
421
422 using value_type = const view_type;
423 using pointer = value_type*;
424 using reference = value_type&;
425 using size_type = std::size_t;
426 using difference_type = std::ptrdiff_t;
427
428 struct sentinel{};
429
430 struct iterator
431 {
432 using iterator_category = std::input_iterator_tag;
433 using difference_type = strtokenizer::difference_type;
434 using value_type = strtokenizer::value_type;
435 using pointer = strtokenizer::pointer;
436 using reference = strtokenizer::reference;
437
438 constexpr bool operator !=(sentinel) const
439 {
440 return !s_.empty();
441 }
442
443 constexpr bool operator ==(sentinel) const
444 {
445 return s_.empty();
446 }
447
448 constexpr iterator& operator =(sentinel)
449 {
450 s_ = {};
451 return *this;
452 }
453
454 constexpr bool operator ==(iterator const& op) const
455 {
456 return s_.size() == op.s_.size();
457 }
458
459 constexpr bool operator !=(iterator const& op) const
460 {
461 return s_.size() != op.s_.size();
462 }
463
464 constexpr value_type operator*() const
465 {
466 return s_.substr(0, pos_);
467 }
468
469 constexpr iterator &operator++()
470 {
471 for (;;) {
472 if (pos_ != s_.size()) {
473 ++pos_;
474 }
475
476 s_.remove_prefix(pos_);
477
478 pos_ = s_.find_first_of(t_->delims_);
479
480 if (pos_ == view_type::npos) {
481 pos_ = s_.size();
482 break;
483 }
484
485 if (pos_ != 0 || !t_->ignore_empty_) {
486 break;
487 }
488 }
489
490 return *this;
491 }
492
493 private:
494 friend strtokenizer;
495
496 constexpr iterator(const strtokenizer *t)
497 : t_(t)
498 , s_(view_type(t_->string_))
499 , pos_(view_type::npos)
500 {
501 operator++();
502 }
503
504 const strtokenizer *t_;
505 view_type s_;
506 size_type pos_;
507 };
508
509 using const_value_type = value_type;
510 using const_pointer = pointer;
511 using const_reference = reference;
512 using const_iterator = iterator;
513
514 constexpr iterator begin() const
515 {
516 return { this };
517 }
518
519 constexpr sentinel end() const
520 {
521 return {};
522 }
523
524 constexpr const_iterator cbegin() const
525 {
526 return { this };
527 }
528
529 constexpr sentinel cend() const
530 {
531 return {};
532 }
533
534public:
535 String string_;
536 Delims delims_;
537 bool ignore_empty_;
538};
539
546template <typename String, typename Delims>
547strtokenizer(String && string, Delims &&delims, bool ignore_empty) -> strtokenizer<String, Delims>;
548
555std::vector<std::string> FZ_PUBLIC_SYMBOL strtok(std::string_view const& tokens, std::string_view const& delims, bool const ignore_empty = true);
556std::vector<std::wstring> FZ_PUBLIC_SYMBOL strtok(std::wstring_view const& tokens, std::wstring_view const& delims, bool const ignore_empty = true);
557inline auto FZ_PUBLIC_SYMBOL strtok(std::string_view const& tokens, char const delim, bool const ignore_empty = true) {
558 return strtok(tokens, std::string_view(&delim, 1), ignore_empty);
559}
560inline auto FZ_PUBLIC_SYMBOL strtok(std::wstring_view const& tokens, wchar_t const delim, bool const ignore_empty = true) {
561 return strtok(tokens, std::wstring_view(&delim, 1), ignore_empty);
562}
563
572std::vector<std::string_view> FZ_PUBLIC_SYMBOL strtok_view(std::string_view const& tokens, std::string_view const& delims, bool const ignore_empty = true);
573std::vector<std::wstring_view> FZ_PUBLIC_SYMBOL strtok_view(std::wstring_view const& tokens, std::wstring_view const& delims, bool const ignore_empty = true);
574inline auto FZ_PUBLIC_SYMBOL strtok_view(std::string_view const& tokens, char const delim, bool const ignore_empty = true) {
575 return strtok_view(tokens, std::string_view(&delim, 1), ignore_empty);
576}
577inline auto FZ_PUBLIC_SYMBOL strtok_view(std::wstring_view const& tokens, wchar_t const delim, bool const ignore_empty = true) {
578 return strtok_view(tokens, std::wstring_view(&delim, 1), ignore_empty);
579}
580
582template<typename T, typename String>
583bool to_integral_impl(String const& s, T & v)
584{
585 if constexpr (std::is_same_v<T, bool>) {
586 unsigned int w{};
587 if (!to_integral_impl(s, w)) {
588 return false;
589 }
590 v = w != 0;
591 return true;
592 }
593 else if constexpr (std::is_enum_v<T>) {
594 return to_integral_impl<std::underlying_type_t<T>>(s, reinterpret_cast<std::underlying_type_t<T>&>(v));
595 }
596 else {
597 bool negative{};
598
599 auto it = s.cbegin();
600 if (it != s.cend() && (*it == '-' || *it == '+')) {
601 if (*it == '-') {
602 if constexpr (std::is_signed_v<T>) {
603 negative = true;
604 }
605 else {
606 return false;
607 }
608 }
609 ++it;
610 }
611
612 if (it == s.cend()) {
613 return false;
614 }
615
616 v = T{};
617 if (negative) {
618 auto constexpr min = std::numeric_limits<T>::min();
619 auto constexpr min10 = min / 10;
620 for (; it != s.cend(); ++it) {
621 auto const& c = *it;
622 if (c < '0' || c > '9') {
623 return false;
624 }
625 if (v < min10) {
626 return false;
627 }
628 v *= 10;
629 auto digit = -static_cast<T>(c - '0');
630 if (min - v > digit) {
631 return false;
632 }
633 v += digit;
634 }
635 }
636 else {
637 auto constexpr max = std::numeric_limits<T>::max();
638 auto constexpr max10 = max / 10;
639 for (; it != s.cend(); ++it) {
640 auto const& c = *it;
641 if (c < '0' || c > '9') {
642 return false;
643 }
644 if (v > max10) {
645 return false;
646 }
647 v *= 10;
648 auto digit = static_cast<T>(c - '0');
649 if (max - v < digit) {
650 return false;
651 }
652 v += digit;
653 }
654 }
655 }
656 return true;
657}
658
660template<typename T>
661T to_integral(std::string_view const& s, T const errorval = T()) {
662 T out{};
663 if (!to_integral_impl<T>(s, out)) {
664 out = errorval;
665 }
666 return out;
667}
668
669template<typename T>
670T to_integral(std::wstring_view const& s, T const errorval = T()) {
671 T out{};
672 if (!to_integral_impl<T>(s, out)) {
673 out = errorval;
674 }
675 return out;
676}
677
678template<typename T, typename StringType>
679T to_integral(std::basic_string_view<StringType> const& s, T const errorval = T()) {
680 T out{};
681 if (!to_integral_impl<T>(s, out)) {
682 out = errorval;
683 }
684 return out;
685}
686
688template<typename T>
689std::optional<T> to_integral_o(std::string_view const& s) {
690 std::optional<T> ret;
691 T out{};
692 if (to_integral_impl<T>(s, out)) {
693 ret = out;
694 }
695 return ret;
696}
697
698template<typename T>
699std::optional<T> to_integral_o(std::wstring_view const& s) {
700 std::optional<T> ret;
701 T out{};
702 if (to_integral_impl<T>(s, out)) {
703 ret = out;
704 }
705 return ret;
706}
707
708template<typename T, typename StringType>
709std::optional<T> to_integral_o(std::basic_string_view<StringType> const& s) {
710 std::optional<T> ret;
711 T out{};
712 if (to_integral_impl<T>(s, out)) {
713 ret = out;
714 }
715 return ret;
716}
717
718
720template<typename String>
721bool str_is_ascii(String const& s) {
722 for (auto const& c : s) {
723 if (static_cast<std::make_unsigned_t<typename String::value_type>>(c) > 127) {
724 return false;
725 }
726 }
727
728 return true;
729}
730
732template<typename String, typename Chars>
733void trim_impl(String & s, Chars const& chars, bool fromLeft, bool fromRight) {
734 size_t const first = fromLeft ? s.find_first_not_of(chars) : 0;
735 if (first == String::npos) {
736 s = String();
737 return;
738 }
739
740 size_t const last = fromRight ? s.find_last_not_of(chars) : s.size();
741 if (last == String::npos) {
742 s = String();
743 return;
744 }
745
746 // Invariant: If first exists, then last >= first
747 s = s.substr(first, last - first + 1);
748}
749
751inline std::string FZ_PUBLIC_SYMBOL trimmed(std::string_view s, std::string_view const& chars = " \r\n\t", bool fromLeft = true, bool fromRight = true)
752{
753 trim_impl(s, chars, fromLeft, fromRight);
754 return std::string(s);
755}
756
757inline std::wstring FZ_PUBLIC_SYMBOL trimmed(std::wstring_view s, std::wstring_view const& chars = L" \r\n\t", bool fromLeft = true, bool fromRight = true)
758{
759 trim_impl(s, chars, fromLeft, fromRight);
760 return std::wstring(s);
761}
762
763inline std::string FZ_PUBLIC_SYMBOL ltrimmed(std::string_view s, std::string_view const& chars = " \r\n\t")
764{
765 trim_impl(s, chars, true, false);
766 return std::string(s);
767}
768
769inline std::wstring FZ_PUBLIC_SYMBOL ltrimmed(std::wstring_view s, std::wstring_view const& chars = L" \r\n\t")
770{
771 trim_impl(s, chars, true, false);
772 return std::wstring(s);
773}
774
775inline std::string FZ_PUBLIC_SYMBOL rtrimmed(std::string_view s, std::string_view const& chars = " \r\n\t")
776{
777 trim_impl(s, chars, false, true);
778 return std::string(s);
779}
780
781inline std::wstring FZ_PUBLIC_SYMBOL rtrimmed(std::wstring_view s, std::wstring_view const& chars = L" \r\n\t")
782{
783 trim_impl(s, chars, false, true);
784 return std::wstring(s);
785}
786
787
789template<typename String, typename std::enable_if_t<std::is_same_v<typename String::value_type, char>, int> = 0>
790inline void trim(String & s, std::string_view const& chars = " \r\n\t", bool fromLeft = true, bool fromRight = true)
791{
792 trim_impl(s, chars, fromLeft, fromRight);
793}
794
795template<typename String, typename std::enable_if_t<std::is_same_v<typename String::value_type, wchar_t>, int> = 0>
796inline void trim(String & s, std::wstring_view const& chars = L" \r\n\t", bool fromLeft = true, bool fromRight = true)
797{
798 trim_impl(s, chars, fromLeft, fromRight);
799}
800
801template<typename String, typename std::enable_if_t<std::is_same_v<typename String::value_type, char>, int> = 0>
802inline void ltrim(String& s, std::string_view const& chars = " \r\n\t")
803{
804 trim_impl(s, chars, true, false);
805}
806
807template<typename String, typename std::enable_if_t<std::is_same_v<typename String::value_type, wchar_t>, int> = 0>
808inline void ltrim(String& s, std::wstring_view const& chars = L" \r\n\t")
809{
810 trim_impl(s, chars, true, false);
811}
812
813template<typename String, typename std::enable_if_t<std::is_same_v<typename String::value_type, char>, int> = 0>
814inline void rtrim(String& s, std::string_view const& chars = " \r\n\t")
815{
816 trim_impl(s, chars, false, true);
817}
818
819template<typename String, typename std::enable_if_t<std::is_same_v<typename String::value_type, wchar_t>, int> = 0>
820inline void rtrim(String & s, std::wstring_view const& chars = L" \r\n\t")
821{
822 trim_impl(s, chars, false, true);
823}
824
829template<bool insensitive_ascii = false, typename String, typename Beginning>
830 std::enable_if_t<std::is_same_v<string_value_type_t<String>, string_value_type_t<Beginning>>,
831bool> starts_with(String const& s, Beginning const& beginning)
832{
833 std::basic_string_view<string_value_type_t<String>> sv(s);
834 std::basic_string_view<string_value_type_t<Beginning>> beginningv(beginning);
835
836 if (beginningv.size() > sv.size()) {
837 return false;
838 }
839
840 if constexpr (insensitive_ascii) {
841 return std::equal(beginningv.begin(), beginningv.end(), sv.begin(), [](auto const& a, auto const& b) {
842 return tolower_ascii(a) == tolower_ascii(b);
843 });
844 } else {
845 return std::equal(beginningv.begin(), beginningv.end(), sv.begin());
846 }
847}
848
853template<bool insensitive_ascii = false, typename String, typename Ending>
854 std::enable_if_t<std::is_same_v<string_value_type_t<String>, string_value_type_t<Ending>>,
855bool> ends_with(String const& s, Ending const& ending)
856{
857 std::basic_string_view<string_value_type_t<String>> sv(s);
858 std::basic_string_view<string_value_type_t<Ending>> endingv(ending);
859
860 if (endingv.size() > sv.size()) {
861 return false;
862 }
863
864 if constexpr (insensitive_ascii) {
865 return std::equal(endingv.rbegin(), endingv.rend(), sv.rbegin(), [](auto const& a, auto const& b) {
866 return tolower_ascii(a) == tolower_ascii(b);
867 });
868 }
869 else {
870 return std::equal(endingv.rbegin(), endingv.rend(), sv.rbegin());
871 }
872}
873
879std::string FZ_PUBLIC_SYMBOL normalize_hyphens(std::string_view const& in);
880std::wstring FZ_PUBLIC_SYMBOL normalize_hyphens(std::wstring_view const& in);
881
883bool FZ_PUBLIC_SYMBOL is_valid_utf8(std::string_view s);
884
905bool FZ_PUBLIC_SYMBOL is_valid_utf8(std::string_view s, size_t & state);
906
912void FZ_PUBLIC_SYMBOL unicode_codepoint_to_utf8_append(std::string& result, uint32_t codepoint);
913
934bool FZ_PUBLIC_SYMBOL utf16be_to_utf8_append(std::string & result, std::string_view data, uint32_t & state);
935
937bool FZ_PUBLIC_SYMBOL utf16le_to_utf8_append(std::string & result, std::string_view data, uint32_t & state);
938
939inline native_string to_native_from_utf8(std::string_view s) {
940#ifdef FZ_WINDOWS
941 return to_wstring_from_utf8(s);
942#else
944#endif
945}
946
947FZ_PUBLIC_SYMBOL void wipe_conversion_cache();
948
949}
950
951#endif
The buffer class is a simple buffer where data can be appended at the end and consumed at the front....
Definition buffer.hpp:28
Small class to return filesystem errors.
Definition fsresult.hpp:26
Container-like class that can be used to iterate over tokens in a string.
Definition string.hpp:406
constexpr strtokenizer(String &&string, Delims &&delims, bool ignore_empty)
strtokenizer class constructor.
Definition string.hpp:416
Definition string.hpp:16
Sets some global macros and further includes string.hpp.
The namespace used by libfilezilla.
Definition apply.hpp:17
size_t strlen(Char const *str)
Returns length of 0-terminated character sequence. Works with both narrow and wide-characters.
Definition string.hpp:284
Char toupper_ascii(Char c)
Converts ASCII lowercase characters to uppercase as if C-locale is used.
Definition string.hpp:134
bool utf16le_to_utf8_append(std::string &result, std::string_view data, uint32_t &state)
Just as utf16be_to_utf8_append but for little-endian UTF-16.
std::vector< std::string_view > strtok_view(std::string_view const &tokens, std::string_view const &delims, bool const ignore_empty=true)
Tokenizes string.
std::enable_if_t< std::is_same_v< string_value_type_t< String >, string_value_type_t< Beginning > >, bool > starts_with(String const &s, Beginning const &beginning)
Tests whether the first string starts with the second string.
Definition string.hpp:831
Char tolower_ascii(Char c)
Converts ASCII uppercase characters to lowercase as if C-locale is used.
Definition string.hpp:122
bool str_is_ascii(String const &s)
Returns true iff the string only has characters in the 7-bit ASCII range.
Definition string.hpp:721
strtokenizer(String &&string, Delims &&delims, bool ignore_empty) -> strtokenizer< String, Delims >
strtokenizer class construction-guide.
auto toString(Arg &&arg) -> typename std::enable_if< std::is_same_v< String, std::string >, decltype(to_string(std::forward< Arg >(arg)))>::type
Calls either fz::to_string or fz::to_wstring depending on the passed template argument.
Definition string.hpp:307
constexpr Char const * choose_string(char const *c, wchar_t const *w)
Returns the function argument of the type matching the template argument.
bool equal_insensitive_ascii(A const &a, B const &b)
Locale-insensitive stricmp.
Definition string.hpp:211
void trim(String &s, std::string_view const &chars=" \r\n\t", bool fromLeft=true, bool fromRight=true)
Remove all leading and trailing whitespace from string.
Definition string.hpp:790
bool is_valid_utf8(std::string_view s)
Verifies that the input data is valid UTF-8.
std::string trimmed(std::string_view s, std::string_view const &chars=" \r\n\t", bool fromLeft=true, bool fromRight=true)
Return passed string with all leading and trailing whitespace removed.
Definition string.hpp:751
std::wstring to_wstring_from_utf8(std::string_view const &in)
Converts from std::string in UTF-8 into std::wstring.
std::string normalize_hyphens(std::string_view const &in)
std::wstring native_string
A string in the system's native character type and encoding. Note: This typedef changes depending on...
Definition string.hpp:69
std::enable_if_t< std::is_same_v< string_value_type_t< String >, string_value_type_t< Ending > >, bool > ends_with(String const &s, Ending const &ending)
Tests whether the first string ends with the second string.
Definition string.hpp:855
bool utf16be_to_utf8_append(std::string &result, std::string_view data, uint32_t &state)
Converts from UTF-16-BE and appends it to the passed string.
std::string to_utf8(std::string_view const &in)
Converts from std::string in native encoding into std::string in UTF-8.
std::vector< std::string > strtok(std::string_view const &tokens, std::string_view const &delims, bool const ignore_empty=true)
Tokenizes string.
std::string to_string(std::wstring_view const &in)
Converts from std::wstring into std::string in system encoding.
std::wstring to_wstring(std::string_view const &in)
Converts from std::string in system encoding into std::wstring.
std::optional< T > to_integral_o(std::string_view const &s)
Converts string to integral type T. If string is not convertible, nullopt.
Definition string.hpp:689
std::string replaced_substrings(std::string_view const &in, std::string_view const &find, std::string_view const &replacement)
Returns in with all occurrences of find in the input string replaced with replacement.
bool replace_substrings(std::string &in, std::string_view const &find, std::string_view const &replacement)
Modifies in, replacing all occurrences of find with replacement.
int stricmp(std::string_view const &a, std::string_view const &b)
Locale-sensitive stricmp.
std::string str_tolower_ascii(std::string_view const &s)
tr_tolower_ascii does for strings what tolower_ascii does for individual characters
void unicode_codepoint_to_utf8_append(std::string &result, uint32_t codepoint)
Encodes a valid Unicode codepoint as UTF-8 and appends it to the passed string.
native_string to_native(std::string_view const &in)
Converts std::string to native_string.
T to_integral(std::string_view const &s, T const errorval=T())
Converts string to integral type T. If string is not convertible, errorval is returned.
Definition string.hpp:661
Comparator to be used for std::map for case-insensitive keys.
Definition string.hpp:188
A type trait to identify the value_type of any string-like type.
Definition string.hpp:156
Definition string.hpp:431
Definition string.hpp:428