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 bool operator ==(iterator const& op) const
449 {
450 return s_.size() == op.s_.size();
451 }
452
453 constexpr bool operator !=(iterator const& op) const
454 {
455 return s_.size() != op.s_.size();
456 }
457
458 constexpr value_type operator*() const
459 {
460 return s_.substr(0, pos_);
461 }
462
463 constexpr iterator &operator++()
464 {
465 for (;;) {
466 if (pos_ != s_.size()) {
467 ++pos_;
468 }
469
470 s_.remove_prefix(pos_);
471
472 pos_ = s_.find_first_of(t_->delims_);
473
474 if (pos_ == view_type::npos) {
475 pos_ = s_.size();
476 break;
477 }
478
479 if (pos_ != 0 || !t_->ignore_empty_) {
480 break;
481 }
482 }
483
484 return *this;
485 }
486
487 private:
488 friend strtokenizer;
489
490 constexpr iterator(const strtokenizer *t)
491 : t_(t)
492 , s_(view_type(t_->string_))
493 , pos_(view_type::npos)
494 {
495 operator++();
496 }
497
498 const strtokenizer *t_;
499 view_type s_;
500 size_type pos_;
501 };
502
503 using const_value_type = value_type;
504 using const_pointer = pointer;
505 using const_reference = reference;
506 using const_iterator = iterator;
507
508 constexpr iterator begin() const
509 {
510 return { this };
511 }
512
513 constexpr sentinel end() const
514 {
515 return {};
516 }
517
518 constexpr const_iterator cbegin() const
519 {
520 return { this };
521 }
522
523 constexpr sentinel cend() const
524 {
525 return {};
526 }
527
528public:
529 String string_;
530 Delims delims_;
531 bool ignore_empty_;
532};
533
540template <typename String, typename Delims>
541strtokenizer(String && string, Delims &&delims, bool ignore_empty) -> strtokenizer<String, Delims>;
542
549std::vector<std::string> FZ_PUBLIC_SYMBOL strtok(std::string_view const& tokens, std::string_view const& delims, bool const ignore_empty = true);
550std::vector<std::wstring> FZ_PUBLIC_SYMBOL strtok(std::wstring_view const& tokens, std::wstring_view const& delims, bool const ignore_empty = true);
551inline auto FZ_PUBLIC_SYMBOL strtok(std::string_view const& tokens, char const delim, bool const ignore_empty = true) {
552 return strtok(tokens, std::string_view(&delim, 1), ignore_empty);
553}
554inline auto FZ_PUBLIC_SYMBOL strtok(std::wstring_view const& tokens, wchar_t const delim, bool const ignore_empty = true) {
555 return strtok(tokens, std::wstring_view(&delim, 1), ignore_empty);
556}
557
566std::vector<std::string_view> FZ_PUBLIC_SYMBOL strtok_view(std::string_view const& tokens, std::string_view const& delims, bool const ignore_empty = true);
567std::vector<std::wstring_view> FZ_PUBLIC_SYMBOL strtok_view(std::wstring_view const& tokens, std::wstring_view const& delims, bool const ignore_empty = true);
568inline auto FZ_PUBLIC_SYMBOL strtok_view(std::string_view const& tokens, char const delim, bool const ignore_empty = true) {
569 return strtok_view(tokens, std::string_view(&delim, 1), ignore_empty);
570}
571inline auto FZ_PUBLIC_SYMBOL strtok_view(std::wstring_view const& tokens, wchar_t const delim, bool const ignore_empty = true) {
572 return strtok_view(tokens, std::wstring_view(&delim, 1), ignore_empty);
573}
574
576template<typename T, typename String>
577bool to_integral_impl(String const& s, T & v)
578{
579 if constexpr (std::is_same_v<T, bool>) {
580 unsigned int w{};
581 if (!to_integral_impl(s, w)) {
582 return false;
583 }
584 v = w != 0;
585 return true;
586 }
587 else if constexpr (std::is_enum_v<T>) {
588 return to_integral_impl<std::underlying_type_t<T>>(s, reinterpret_cast<std::underlying_type_t<T>&>(v));
589 }
590 else {
591 bool negative{};
592
593 auto it = s.cbegin();
594 if (it != s.cend() && (*it == '-' || *it == '+')) {
595 if (*it == '-') {
596 if constexpr (std::is_signed_v<T>) {
597 negative = true;
598 }
599 else {
600 return false;
601 }
602 }
603 ++it;
604 }
605
606 if (it == s.cend()) {
607 return false;
608 }
609
610 v = T{};
611 if (negative) {
612 auto constexpr min = std::numeric_limits<T>::min();
613 auto constexpr min10 = min / 10;
614 for (; it != s.cend(); ++it) {
615 auto const& c = *it;
616 if (c < '0' || c > '9') {
617 return false;
618 }
619 if (v < min10) {
620 return false;
621 }
622 v *= 10;
623 auto digit = -static_cast<T>(c - '0');
624 if (min - v > digit) {
625 return false;
626 }
627 v += digit;
628 }
629 }
630 else {
631 auto constexpr max = std::numeric_limits<T>::max();
632 auto constexpr max10 = max / 10;
633 for (; it != s.cend(); ++it) {
634 auto const& c = *it;
635 if (c < '0' || c > '9') {
636 return false;
637 }
638 if (v > max10) {
639 return false;
640 }
641 v *= 10;
642 auto digit = static_cast<T>(c - '0');
643 if (max - v < digit) {
644 return false;
645 }
646 v += digit;
647 }
648 }
649 }
650 return true;
651}
652
654template<typename T>
655T to_integral(std::string_view const& s, T const errorval = T()) {
656 T out{};
657 if (!to_integral_impl<T>(s, out)) {
658 out = errorval;
659 }
660 return out;
661}
662
663template<typename T>
664T to_integral(std::wstring_view const& s, T const errorval = T()) {
665 T out{};
666 if (!to_integral_impl<T>(s, out)) {
667 out = errorval;
668 }
669 return out;
670}
671
672template<typename T, typename StringType>
673T to_integral(std::basic_string_view<StringType> const& s, T const errorval = T()) {
674 T out{};
675 if (!to_integral_impl<T>(s, out)) {
676 out = errorval;
677 }
678 return out;
679}
680
682template<typename T>
683std::optional<T> to_integral_o(std::string_view const& s) {
684 std::optional<T> ret;
685 T out{};
686 if (to_integral_impl<T>(s, out)) {
687 ret = out;
688 }
689 return ret;
690}
691
692template<typename T>
693std::optional<T> to_integral_o(std::wstring_view const& s) {
694 std::optional<T> ret;
695 T out{};
696 if (to_integral_impl<T>(s, out)) {
697 ret = out;
698 }
699 return ret;
700}
701
702template<typename T, typename StringType>
703std::optional<T> to_integral_o(std::basic_string_view<StringType> const& s) {
704 std::optional<T> ret;
705 T out{};
706 if (to_integral_impl<T>(s, out)) {
707 ret = out;
708 }
709 return ret;
710}
711
712
714template<typename String>
715bool str_is_ascii(String const& s) {
716 for (auto const& c : s) {
717 if (static_cast<std::make_unsigned_t<typename String::value_type>>(c) > 127) {
718 return false;
719 }
720 }
721
722 return true;
723}
724
726template<typename String, typename Chars>
727void trim_impl(String & s, Chars const& chars, bool fromLeft, bool fromRight) {
728 size_t const first = fromLeft ? s.find_first_not_of(chars) : 0;
729 if (first == String::npos) {
730 s = String();
731 return;
732 }
733
734 size_t const last = fromRight ? s.find_last_not_of(chars) : s.size();
735 if (last == String::npos) {
736 s = String();
737 return;
738 }
739
740 // Invariant: If first exists, then last >= first
741 s = s.substr(first, last - first + 1);
742}
743
745inline std::string FZ_PUBLIC_SYMBOL trimmed(std::string_view s, std::string_view const& chars = " \r\n\t", bool fromLeft = true, bool fromRight = true)
746{
747 trim_impl(s, chars, fromLeft, fromRight);
748 return std::string(s);
749}
750
751inline 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)
752{
753 trim_impl(s, chars, fromLeft, fromRight);
754 return std::wstring(s);
755}
756
757inline std::string FZ_PUBLIC_SYMBOL ltrimmed(std::string_view s, std::string_view const& chars = " \r\n\t")
758{
759 trim_impl(s, chars, true, false);
760 return std::string(s);
761}
762
763inline std::wstring FZ_PUBLIC_SYMBOL ltrimmed(std::wstring_view s, std::wstring_view const& chars = L" \r\n\t")
764{
765 trim_impl(s, chars, true, false);
766 return std::wstring(s);
767}
768
769inline std::string FZ_PUBLIC_SYMBOL rtrimmed(std::string_view s, std::string_view const& chars = " \r\n\t")
770{
771 trim_impl(s, chars, false, true);
772 return std::string(s);
773}
774
775inline std::wstring FZ_PUBLIC_SYMBOL rtrimmed(std::wstring_view s, std::wstring_view const& chars = L" \r\n\t")
776{
777 trim_impl(s, chars, false, true);
778 return std::wstring(s);
779}
780
781
783template<typename String, typename std::enable_if_t<std::is_same_v<typename String::value_type, char>, int> = 0>
784inline void trim(String & s, std::string_view const& chars = " \r\n\t", bool fromLeft = true, bool fromRight = true)
785{
786 trim_impl(s, chars, fromLeft, fromRight);
787}
788
789template<typename String, typename std::enable_if_t<std::is_same_v<typename String::value_type, wchar_t>, int> = 0>
790inline void trim(String & s, std::wstring_view const& chars = L" \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, char>, int> = 0>
796inline void ltrim(String& s, std::string_view const& chars = " \r\n\t")
797{
798 trim_impl(s, chars, true, false);
799}
800
801template<typename String, typename std::enable_if_t<std::is_same_v<typename String::value_type, wchar_t>, int> = 0>
802inline void ltrim(String& s, std::wstring_view const& chars = L" \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, char>, int> = 0>
808inline void rtrim(String& s, std::string_view const& chars = " \r\n\t")
809{
810 trim_impl(s, chars, false, true);
811}
812
813template<typename String, typename std::enable_if_t<std::is_same_v<typename String::value_type, wchar_t>, int> = 0>
814inline void rtrim(String & s, std::wstring_view const& chars = L" \r\n\t")
815{
816 trim_impl(s, chars, false, true);
817}
818
823template<bool insensitive_ascii = false, typename String, typename Beginning>
824 std::enable_if_t<std::is_same_v<string_value_type_t<String>, string_value_type_t<Beginning>>,
825bool> starts_with(String const& s, Beginning const& beginning)
826{
827 std::basic_string_view<string_value_type_t<String>> sv(s);
828 std::basic_string_view<string_value_type_t<Beginning>> beginningv(beginning);
829
830 if (beginningv.size() > sv.size()) {
831 return false;
832 }
833
834 if constexpr (insensitive_ascii) {
835 return std::equal(beginningv.begin(), beginningv.end(), sv.begin(), [](auto const& a, auto const& b) {
836 return tolower_ascii(a) == tolower_ascii(b);
837 });
838 } else {
839 return std::equal(beginningv.begin(), beginningv.end(), sv.begin());
840 }
841}
842
847template<bool insensitive_ascii = false, typename String, typename Ending>
848 std::enable_if_t<std::is_same_v<string_value_type_t<String>, string_value_type_t<Ending>>,
849bool> ends_with(String const& s, Ending const& ending)
850{
851 std::basic_string_view<string_value_type_t<String>> sv(s);
852 std::basic_string_view<string_value_type_t<Ending>> endingv(ending);
853
854 if (endingv.size() > sv.size()) {
855 return false;
856 }
857
858 if constexpr (insensitive_ascii) {
859 return std::equal(endingv.rbegin(), endingv.rend(), sv.rbegin(), [](auto const& a, auto const& b) {
860 return tolower_ascii(a) == tolower_ascii(b);
861 });
862 }
863 else {
864 return std::equal(endingv.rbegin(), endingv.rend(), sv.rbegin());
865 }
866}
867
873std::string FZ_PUBLIC_SYMBOL normalize_hyphens(std::string_view const& in);
874std::wstring FZ_PUBLIC_SYMBOL normalize_hyphens(std::wstring_view const& in);
875
877bool FZ_PUBLIC_SYMBOL is_valid_utf8(std::string_view s);
878
899bool FZ_PUBLIC_SYMBOL is_valid_utf8(std::string_view s, size_t & state);
900
906void FZ_PUBLIC_SYMBOL unicode_codepoint_to_utf8_append(std::string& result, uint32_t codepoint);
907
928bool FZ_PUBLIC_SYMBOL utf16be_to_utf8_append(std::string & result, std::string_view data, uint32_t & state);
929
931bool FZ_PUBLIC_SYMBOL utf16le_to_utf8_append(std::string & result, std::string_view data, uint32_t & state);
932
933inline native_string to_native_from_utf8(std::string_view s) {
934#ifdef FZ_WINDOWS
935 return to_wstring_from_utf8(s);
936#else
938#endif
939}
940
941FZ_PUBLIC_SYMBOL void wipe_conversion_cache();
942
943}
944
945#endif
The buffer class is a simple buffer where data can be appended at the end and consumed at the front....
Definition buffer.hpp:27
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:825
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:715
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:784
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:745
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:849
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:683
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:655
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