78 using base_type = std::basic_string<char_t, traits_t, allocator_t>;
80 using traits_type =
typename base_type::traits_type;
82 using value_type =
typename base_type::value_type;
84 using allocator_type =
typename base_type::allocator_type;
86 using size_type =
typename base_type::size_type;
88 using difference_type =
typename base_type::difference_type;
90 using reference =
typename base_type::reference;
92 using const_reference =
typename base_type::const_reference;
94 using pointer =
typename base_type::pointer;
96 using const_pointer =
typename base_type::const_pointer;
104 using reverse_iterator =
typename base_type::reverse_iterator;
106 using const_reverse_iterator =
typename base_type::const_reverse_iterator;
119 inline static constexpr size_type npos = base_type::npos;
129 explicit basic_string(
const allocator_type & allocator)
noexcept;
134 if constexpr(std::is_same_v<char, char_t>) chars_ = str.chars_;
135 else chars_ = __xtd_convert_to_string<value_type>(str.chars_);
141 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ = str.chars_;
142 else chars_ = __xtd_convert_to_string<value_type>(str.chars_);
147 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ = str.chars_;
148 else chars_ = __xtd_convert_to_string<value_type>(str.chars_);
153 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ = str.chars_;
154 else chars_ = __xtd_convert_to_string<value_type>(str.chars_);
159 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ = str.chars_;
160 else chars_ = __xtd_convert_to_string<value_type>(str.chars_);
167 if constexpr(std::is_same_v<char, char_t>) chars_ = base_type(str.chars_, allocator);
168 else chars_ = base_type(__xtd_convert_to_string<value_type>(str.chars_), allocator);
174 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ = base_type(str.chars_, allocator);
175 else chars_ = base_type(__xtd_convert_to_string<value_type>(str.chars_), allocator);
181 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ = base_type(str.chars_, allocator);
182 else chars_ = base_type(__xtd_convert_to_string<value_type>(str.chars_), allocator);
188 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ = base_type(str.chars_, allocator);
189 else chars_ = base_type(__xtd_convert_to_string<value_type>(str.chars_), allocator);
195 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ = base_type(str.chars_, allocator);
196 else chars_ = base_type(__xtd_convert_to_string<value_type>(str.chars_), allocator);
205 if constexpr(std::is_same_v<char, char_t>) chars_ = base_type(str.chars_, index);
206 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<char>(str.chars_, index)));
214 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ = base_type(str.chars_, index);
215 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str.chars_, index)));
223 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ = base_type(str.chars_, index);
224 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str.chars_, index)));
232 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ = base_type(str.chars_, index);
233 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str.chars_, index)));
241 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ = base_type(str.chars_, index);
242 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str.chars_, index)));
252 if constexpr(std::is_same_v<char, char_t>) chars_ = base_type(str.chars_, index, allocator);
253 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<char>(str.chars_, index)), allocator);
262 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ = base_type(str.chars_, index, allocator);
263 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str.chars_, index)), allocator);
272 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ = base_type(str.chars_, index, allocator);
273 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str.chars_, index)), allocator);
282 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ = base_type(str.chars_, index, allocator);
283 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str.chars_, index)), allocator);
292 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ = base_type(str.chars_, index, allocator);
293 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str.chars_, index)), allocator);
303 if constexpr(std::is_same_v<char, char_t>) chars_ = base_type(str.chars_, index,
count);
304 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<char>(str.chars_, index,
count)));
313 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ = base_type(str.chars_, index,
count);
314 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str.chars_, index,
count)));
323 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ = base_type(str.chars_, index,
count);
324 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str.chars_, index,
count)));
333 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ = base_type(str.chars_, index,
count);
334 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str.chars_, index,
count)));
343 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ = base_type(str.chars_, index,
count);
344 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str.chars_, index,
count)));
355 if constexpr(std::is_same_v<char, char_t>) chars_ = base_type(str.chars_, index,
count, allocator);
356 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<char>(str.chars_, index,
count)), allocator);
366 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ = base_type(str.chars_, index,
count, allocator);
367 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str.chars_, index,
count)), allocator);
377 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ = base_type(str.chars_, index,
count, allocator);
378 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str.chars_, index,
count)), allocator);
388 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ = base_type(str.chars_, index,
count, allocator);
389 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str.chars_, index,
count)), allocator);
399 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ = base_type(str.chars_, index,
count, allocator);
400 else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str.chars_, index,
count)), allocator);
510 if constexpr(std::is_same_v<char, char_t>) chars_ = std::basic_string<char>(str);
511 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<char>(str));
517 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ = std::basic_string<xtd::char16>(str);
518 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str));
524 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ = std::basic_string<xtd::char32>(str);
525 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str));
531 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ = std::basic_string<xtd::char8>(str);
532 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str));
538 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ = std::basic_string<xtd::wchar>(str);
539 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str));
545 basic_string(
const char* str,
const allocator_type & allocator) {
547 if constexpr(std::is_same_v<char, char_t>) chars_ = std::basic_string<char>(str, allocator);
548 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<char>(str), allocator);
555 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ = std::basic_string<xtd::char16>(str, allocator);
556 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str), allocator);
563 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ = std::basic_string<xtd::char32>(str, allocator);
564 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str), allocator);
571 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ = std::basic_string<xtd::char8>(str, allocator);
572 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str), allocator);
579 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ = std::basic_string<xtd::wchar>(str);
580 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str));
587 if constexpr(std::is_same_v<char, char_t>) chars_ = std::basic_string<char>(str,
count);
588 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<char>(str,
count));
594 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ = std::basic_string<xtd::char16>(str,
count);
595 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str,
count));
601 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ = std::basic_string<xtd::char32>(str,
count);
602 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str,
count));
608 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ = std::basic_string<xtd::char8>(str,
count);
609 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str,
count));
615 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ = std::basic_string<xtd::wchar>(str,
count);
616 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str,
count));
625 if constexpr(std::is_same_v<char, char_t>) chars_ = std::basic_string<char>(str,
count, allocator);
626 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<char>(str,
count), allocator);
634 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ = std::basic_string<xtd::char16>(str,
count, allocator);
635 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str,
count), allocator);
643 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ = std::basic_string<xtd::char32>(str,
count, allocator);
644 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str,
count), allocator);
652 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ = std::basic_string<xtd::char8>(str,
count, allocator);
653 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str,
count), allocator);
661 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ = std::basic_string<xtd::wchar>(str,
count, allocator);
662 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str,
count), allocator);
667 basic_string(
const std::basic_string<char>& str)
noexcept {
668 if constexpr(std::is_same_v<char, char_t>) chars_ = str;
669 else chars_ = __xtd_convert_to_string<value_type>(str);
673 basic_string(
const std::basic_string<xtd::char16>& str)
noexcept {
674 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ = str;
675 else chars_ = __xtd_convert_to_string<value_type>(str);
679 basic_string(
const std::basic_string<xtd::char32>& str)
noexcept {
680 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ = str;
681 else chars_ = __xtd_convert_to_string<value_type>(str);
685 basic_string(
const std::basic_string<xtd::char8>& str)
noexcept {
686 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ = str;
687 else chars_ = __xtd_convert_to_string<value_type>(str);
691 basic_string(
const std::basic_string<xtd::wchar>& str)
noexcept {
692 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ = str;
693 else chars_ = __xtd_convert_to_string<value_type>(str);
699 basic_string(
const std::basic_string<char>& str,
const allocator_type & allocator)
noexcept {
700 if constexpr(std::is_same_v<char, char_t>) chars_ = base_type(str, allocator);
701 else chars_ = base_type(__xtd_convert_to_string<value_type>(str), allocator);
706 basic_string(
const std::basic_string<xtd::char16>& str,
const allocator_type & allocator)
noexcept {
707 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ = base_type(str, allocator);
708 else chars_ = base_type(__xtd_convert_to_string<value_type>(str), allocator);
713 basic_string(
const std::basic_string<xtd::char32>& str,
const allocator_type & allocator)
noexcept {
714 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ = base_type(str, allocator);
715 else chars_ = base_type(__xtd_convert_to_string<value_type>(str), allocator);
720 basic_string(
const std::basic_string<xtd::char8>& str,
const allocator_type & allocator)
noexcept {
721 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ = base_type(str, allocator);
722 else chars_ = base_type(__xtd_convert_to_string<value_type>(str), allocator);
727 basic_string(
const std::basic_string<xtd::wchar>& str,
const allocator_type & allocator)
noexcept {
728 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ = base_type(str, allocator);
729 else chars_ = base_type(__xtd_convert_to_string<value_type>(str), allocator);
735 template<
class input_iterator_t>
741 template<
class input_iterator_t>
747 template<
class string_view_like_t>
748 explicit constexpr basic_string(
const string_view_like_t& string_view) : chars_(string_view) {}
752 template<
class string_view_like_t>
753 explicit constexpr basic_string(
const string_view_like_t& string_view,
const allocator_type & allocator) : chars_(string_view, allocator) {}
759 template<
class string_view_like_t>
760 constexpr basic_string(
const string_view_like_t& string_view, size_type index, size_type
count) : chars_(string_view, index,
count) {}
766 template<
class string_view_like_t>
767 constexpr basic_string(
const string_view_like_t& string_view, size_type index, size_type
count,
const allocator_type & allocator) : chars_(string_view, index,
count, allocator) {}
788 basic_string(std::initializer_list<char> il,
const allocator_type & allocator) :
basic_string(std::basic_string<char>(il), allocator) {}
792 basic_string(std::initializer_list<xtd::char16> il,
const allocator_type & allocator) :
basic_string(std::basic_string<xtd::char16>(il), allocator) {}
796 basic_string(std::initializer_list<xtd::char32> il,
const allocator_type & allocator) :
basic_string(std::basic_string<xtd::char32>(il), allocator) {}
800 basic_string(std::initializer_list<xtd::char8> il,
const allocator_type & allocator) :
basic_string(std::basic_string<xtd::char8>(il), allocator) {}
804 basic_string(std::initializer_list<xtd::wchar> il,
const allocator_type & allocator) :
basic_string(std::basic_string<xtd::wchar>(il), allocator) {}
827 const_pointer c_str()
const noexcept {
return chars_.c_str();}
831 size_type capacity()
const noexcept {
return chars_.capacity();}
839 const_reverse_iterator
crbegin()
const {
return chars_.crbegin();}
843 const base_type & chars()
const noexcept {
return chars_;}
847 base_type & chars()
noexcept {
return chars_;}
855 const_reverse_iterator
crend()
const {
return chars_.crend();}
864 const_pointer
data()
const noexcept {
return chars_.data();}
868 bool empty()
const noexcept {
return chars_.empty();}
882 size_type
length()
const noexcept {
return chars_.size();}
886 size_type max_size()
const noexcept {
return chars_.max_size();}
890 const_reverse_iterator
rbegin()
const {
return chars_.crbegin();}
894 const_reverse_iterator
rend()
const {
return chars_.crend();}
898 size_type
size()
const noexcept {
return chars_.size();}
907 const_reference
at(size_type pos)
const {
return operator [](pos);}
949 int32 compare(size_type pos1, size_type count1,
const basic_string & str)
const {
return chars_.compare(pos1, count1, str);}
973 int32 compare(size_type pos1, size_type count1,
const basic_string & str, size_type pos2)
const {
return chars_.compare(pos1, count1, str, pos2);}
998 int32 compare(size_type pos1, size_type count1,
const basic_string & str, size_type pos2, size_type count2)
const {
return chars_.compare(pos1, count1, str, pos2, count2);}
1017 int32 compare(const_pointer
s)
const {
return chars_.compare(
s);}
1039 int32 compare(size_type pos1, size_type count1, const_pointer
s)
const {
return chars_.compare(pos1, count1,
s);}
1062 int32 compare(size_type pos1, size_type count1, const_pointer
s, size_type count2)
const {
return chars_.compare(pos1, count1,
s, count2);}
1111 if (ignore_case)
return to_upper().chars_ == value.to_upper().chars_;
1112 return chars_ == value.chars_;
1124 if (ignore_case)
return to_lower().rfind(
static_cast<value_type>(tolower(value))) ==
size() - 1;
1142 return rfind(value) + value.size() ==
size();
1162 size_type
find(const_pointer
s, size_type pos, size_type
count)
const {
return chars_.find(
s, pos,
count);}
1168 size_type
find(const_pointer
s)
const {
return chars_.find(
s);}
1175 size_type
find(const_pointer
s, size_type pos)
const {
return chars_.find(
s, pos);}
1219 size_type
find_first_of(const_pointer
s, size_type pos)
const {
return chars_.find_first_of(
s, pos);}
1230 size_type
find_first_of(char_t ch, size_type pos)
const {
return chars_.find_first_of(ch, pos);}
1274 size_type
find_first_not_of(char_t ch, size_type pos)
const {
return chars_.find_first_not_of(ch, pos);}
1307 size_type
find_last_of(const_pointer
s, size_type pos)
const {
return chars_.find_last_of(
s, pos);}
1318 size_type
find_last_of(char_t ch, size_type pos)
const {
return chars_.find_last_of(ch, pos);}
1351 size_type
find_last_not_of(const_pointer
s, size_type pos)
const {
return chars_.find_last_not_of(
s, pos);}
1362 size_type
find_last_not_of(char_t ch, size_type pos)
const {
return chars_.find_last_not_of(ch, pos);}
1379 explicit basic_string_enumerator(
const basic_string & chars) : chars_(chars) {}
1381 const value_type & current()
const override {
return chars_[index_];}
1383 bool move_next()
override {
return ++index_ < chars_.size();}
1385 void reset()
override {index_ = basic_string::npos;}
1411 auto result =
find(value, start_index);
1412 return result > start_index +
count ? npos : result;
1431 auto result =
find(value, start_index);
1432 return result > start_index +
count ? npos : result;
1466 auto result = *
this;
1467 result.chars_.insert(start_index, value);
1474 [[deprecated(
"Replaced by xtd::basic_string::is_empty(const xtd::basic_string&) - Will be removed in version 0.4.0.")]]
1495 auto result =
rfind(value, start_index +
count - value.size());
1496 return result < start_index ? npos : result;
1517 auto result =
rfind(value, start_index +
count - 1);
1518 return result < start_index ? npos : result;
1586 std::wstringstream ss;
1587 if constexpr(std::is_same_v<xtd::wchar, value_type>) ss << std::quoted(chars_, delimiter,
escape);
1588 else ss << std::quoted(__xtd_convert_to_string<xtd::wchar>(chars_),
static_cast<xtd::wchar>(delimiter),
static_cast<xtd::wchar>(
escape));
1602 auto result = *
this;
1603 result.chars_.erase(start_index,
count);
1618 auto result = *
this;
1619 auto old_size = old_string.size();
1620 auto new_size = new_string.size();
1623 index = result.find(old_string, index);
1624 if (index == npos)
break;
1625 if (old_size == new_size) result.chars_.replace(index, old_size, new_string);
1627 result.chars_.erase(index, old_string.size());
1628 result.chars_.insert(index, new_string);
1630 index += new_string.size();
1644 size_type
rfind(
const basic_string & str, size_type pos)
const {
return chars_.rfind(str, pos);}
1658 size_type
rfind(const_pointer
s)
const {
return chars_.rfind(
s);}
1665 size_type
rfind(const_pointer
s, size_type pos)
const {
return chars_.rfind(
s, pos);}
1676 size_type
rfind(
value_type ch, size_type pos)
const {
return chars_.rfind(ch, pos);}
1682 xtd::array<basic_string> split() const noexcept;
1732 xtd::array<basic_string> split(const xtd::array<
value_type>& separators) const noexcept;
1758 xtd::array<basic_string> split(const xtd::array<
value_type>& separators, xtd::
size count) const noexcept;
1776 bool starts_with(
value_type value) const noexcept {
return starts_with(value,
false);}
1782 bool starts_with(
value_type value,
bool ignore_case)
const noexcept {
1783 if (ignore_case)
return to_lower().find(
static_cast<value_type>(tolower(value))) == 0;
1784 return find(value) == 0;
1803 return find(value) == 0;
1810 basic_string substr()
const {
return chars_.substr();}
1816 basic_string substr(size_type pos)
const {
1818 return chars_.substr(pos);
1826 basic_string substr(size_type pos, size_type
count)
const {
1828 return chars_.substr(pos,
count);
1836 basic_string substring(
xtd::size start_index)
const {
1838 return substr(start_index);
1847 return substr(start_index,
length);
1852 xtd::array<value_type>
to_array() const noexcept;
1865 xtd::array<
value_type> to_char_array() const noexcept;
1874 basic_string to_lower() const noexcept {
1875 auto result = basic_string::empty_string;
1876 std::for_each(chars_.begin(), chars_.end(), [&](
auto c) {result += static_cast<value_type>(std::tolower(c));});
1883 basic_string<char>
to_string() const noexcept
override {
1884 if constexpr(std::is_same_v<char, char_t>)
return chars_;
1885 else return __xtd_convert_to_string<char>(chars_);
1890 basic_string to_title_case() const noexcept;
1894 basic_string<xtd::
char16> to_u16string() const noexcept {
1895 if constexpr(std::is_same_v<xtd::char16, char_t>)
return chars_;
1896 else return __xtd_convert_to_string<xtd::char16>(chars_);
1901 basic_string<xtd::char32> to_u32string() const noexcept {
1902 if constexpr(std::is_same_v<xtd::char32, char_t>)
return chars_;
1903 else return __xtd_convert_to_string<xtd::char32>(chars_);
1908 basic_string<xtd::char8> to_u8string() const noexcept {
1909 if constexpr(std::is_same_v<xtd::char8, char_t>)
return chars_;
1910 else return __xtd_convert_to_string<xtd::char8>(chars_);
1915 basic_string to_upper() const noexcept {
1916 auto result = basic_string::empty_string;
1917 std::for_each(chars_.begin(), chars_.end(), [&](
auto c) {result += static_cast<value_type>(std::toupper(c));});
1923 basic_string<xtd::wchar> to_wstring() const noexcept {
1924 if constexpr(std::is_same_v<xtd::wchar, char_t>)
return chars_;
1925 else return __xtd_convert_to_string<xtd::wchar>(chars_);
1932 basic_string trim() const noexcept {
return trim(default_trim_chars);}
1937 basic_string trim(
value_type trim_char)
const noexcept;
1942 basic_string trim(
const xtd::array<value_type>& trim_chars)
const noexcept;
1948 basic_string trim_end() const noexcept {
return trim_end(default_trim_chars);}
1953 basic_string trim_end(
value_type trim_char)
const noexcept;
1958 basic_string trim_end(
const xtd::array<value_type>& trim_chars)
const noexcept;
1964 basic_string trim_start() const noexcept {
return trim_start(default_trim_chars);}
1969 basic_string trim_start(
value_type trim_char)
const noexcept;
1974 basic_string trim_start(
const xtd::array<value_type>& trim_chars)
const noexcept;
1984 template<
class object_t>
1985 [[deprecated(
"Replaced by typeof_<object_t>().name() - Will be removed in version 0.4.0.")]]
1986 static basic_string class_name() {
return get_class_name(full_class_name<object_t>());}
1991 template<
class object_t>
1992 [[deprecated(
"Replaced by typeof_(object).name() - Will be removed in version 0.4.0.")]]
1993 static basic_string class_name(
const object_t&
object) {
return get_class_name(full_class_name(
object));}
1998 [[deprecated(
"Replaced by typeof_(info).name() - Will be removed in version 0.4.0.")]]
1999 static basic_string class_name(
const std::type_info & info) {
return __xtd_get_class_name(info);}
2010 static int32 compare(
const basic_string & str_a,
const basic_string & str_b)
noexcept {
return compare(str_a, str_b,
false);}
2059 static int32 compare(
const basic_string & str_a,
xtd::size index_a,
const basic_string & str_b,
xtd::size index_b,
xtd::size length,
bool ignore_case) {
return compare(str_a, index_a, str_b, index_b,
length, ignore_case ?
xtd::string_comparison::ordinal_ignore_case :
xtd::string_comparison::ordinal);}
2081 static basic_string
concat(
const basic_string & str_a,
const basic_string & str_b,
const basic_string & str_c,
const basic_string & str_d)
noexcept {
return str_a + str_b + str_c + str_d;}
2088 template<
class object_a_t,
class object_b_t,
class object_c_t,
class object_d_t>
2089 static basic_string
concat(object_a_t obj_a, object_b_t obj_b, object_c_t obj_c, object_d_t obj_d)
noexcept {
return format(
"{}{}{}{}", obj_a, obj_b, obj_c, obj_d);}
2095 static basic_string
concat(
const basic_string & str_a,
const basic_string & str_b,
const basic_string & str_c)
noexcept {
return str_a + str_b + str_c;}
2101 template<
class object_a_t,
class object_b_t,
class object_c_t>
2102 static basic_string
concat(object_a_t obj_a, object_b_t obj_b, object_c_t obj_c)
noexcept {
return format(
"{}{}{}", obj_a, obj_b, obj_c);}
2107 static basic_string
concat(
const basic_string & str_a,
const basic_string & str_b)
noexcept {
return str_a + str_b;}
2112 template<
class object_a_t,
class object_b_t>
2113 static basic_string
concat(object_a_t obj_a, object_b_t obj_b)
noexcept {
return format(
"{}{}", obj_a, obj_b);}
2117 static basic_string
concat(
const xtd::array<basic_string>& values)
noexcept;
2119 static basic_string
concat(
const xtd::array<const_pointer>& values)
noexcept;
2120 template<
class other_
char_t>
2121 static basic_string
concat(
const xtd::array<const other_char_t*>& values)
noexcept;
2122 static basic_string
concat(
const std::initializer_list<basic_string>& values)
noexcept {
2123 auto result = basic_string::empty_string;
2124 std::for_each(values.begin(), values.end(), [&](
const auto & item) {result += item;});
2127 static basic_string
concat(
const std::initializer_list<const_pointer>& values)
noexcept {
2128 auto result = basic_string::empty_string;
2129 std::for_each(values.begin(), values.end(), [&](
const auto & item) {result += item;});
2132 template<
class other_
char_t>
2133 static basic_string
concat(
const std::initializer_list<const other_char_t*>& values)
noexcept {
2134 auto result = basic_string::empty_string;
2135 std::for_each(values.begin(), values.end(), [&](
const auto & item) {result += item;});
2142 template<
class object_t>
2143 static basic_string
concat(
const xtd::array<object_t>& args)
noexcept;
2145 template<
class object_t>
2146 static basic_string
concat(
const std::initializer_list<object_t>& args)
noexcept {
2147 basic_string result;
2148 for (
const auto& arg : args)
2149 result +=
format(
"{}", arg);
2156 template<
class value_t>
2157 static basic_string
concat(value_t value)
noexcept {
2158 return format(
"{}", value);
2181 static basic_string demangle(
const basic_string & name) {
2182 if constexpr(std::is_same_v<char, char_t>)
return __xtd_demangle(
name.chars());
2183 else return __xtd_demangle(__xtd_convert_to_string<char>(
name.chars()));
2191 static bool equals(
const basic_string &
a,
const basic_string &
b)
noexcept{
return a.equals(
b);}
2197 template<
class char_a_t,
class char_b_t>
2198 static bool equals(
const char_a_t*
a,
const char_b_t*
b)
noexcept{
return basic_string {
a}.
equals(basic_string {
b});}
2206 static bool equals(
const basic_string &
a,
const basic_string &
b,
bool ignore_case)
noexcept {
return a.equals(
b, ignore_case);}
2213 template<
class char_a_t,
class char_b_t>
2214 static bool equals(
const char_a_t*
a,
const char_b_t*
b,
bool ignore_case)
noexcept{
return basic_string {
a}.
equals(basic_string {
b}, ignore_case);}
2222 template<
class ...args_t>
2223 static basic_string
format(
const basic_string<char>& fmt, args_t&& ... args);
2229 template<
class object_t>
2230 [[deprecated(
"Replaced by typeof_<object_t>().full_name() - Will be removed in version 0.4.0.")]]
2231 static basic_string full_class_name() {
return demangle(
typeid(object_t).
name());}
2236 template<
class object_t>
2237 [[deprecated(
"Replaced by typeof_(object).full_name() - Will be removed in version 0.4.0.")]]
2238 static basic_string full_class_name(
const object_t&
object) {
return demangle(
typeid(
object).
name());}
2243 [[deprecated(
"Replaced by typeof_(info).full_name() - Will be removed in version 0.4.0.")]]
2244 static basic_string full_class_name(
const std::type_info & info) {
return __xtd_get_full_class_name(info);}
2249 static bool is_empty(
const xtd::basic_string<value_type, traits_type, allocator_type>&
string)
noexcept {
return !
string.length();}
2257 template<
class collection_t>
2258 static basic_string join(
const basic_string
separator,
const collection_t& values)
noexcept {
2260 basic_string result;
2261 for (
const auto& item : values)
2272 template<
class collection_t>
2273 static basic_string join(
const basic_string &
separator,
const collection_t& values,
xtd::size index) {
return join(
separator, values, index, values.size() - index);}
2282 template<
class collection_t>
2286 basic_string result;
2287 for (
const auto& item : values) {
2288 if (
i >= index) result +=
format(
"{}{}", (
i != index ?
separator : basic_string {}), item);
2289 if (++
i >= index +
count)
break;
2295 template<
class value_t>
2296 static basic_string join(
const basic_string &
separator,
const std::initializer_list<value_t>& values)
noexcept;
2297 template<
class value_t>
2298 static basic_string join(
const basic_string &
separator,
const std::initializer_list<value_t>& values,
xtd::size index);
2299 template<
class value_t>
2306 template<
class value_t>
2307 static value_t
parse(
const basic_string & str) {
2371 template<
class ...args_t>
2372 static basic_string
sprintf(
const basic_string & fmt, args_t&& ... args)
noexcept {
return __sprintf(fmt.c_str(), convert_param(std::forward<args_t>(args)) ...);}
2378 template<
class value_t>
2379 static bool try_parse(
const basic_string & str, value_t& value)
noexcept {
2398 return chars_[index];
2403 operator const base_type & ()
const noexcept {
return chars_;}
2408 basic_string& operator =(
const basic_string<char>& str)
noexcept {
2409 if constexpr(std::is_same<char_t, char>::value) chars_ = str.chars_;
2410 else chars_ = __xtd_convert_to_string<value_type>(str.chars());
2416 basic_string& operator =(
const basic_string<xtd::char16>& str)
noexcept {
2417 if constexpr(std::is_same<char_t, xtd::char16>::value) chars_ = str.chars_;
2418 else chars_ = __xtd_convert_to_string<value_type>(str.chars());
2424 basic_string& operator =(
const basic_string<xtd::char32>& str)
noexcept {
2425 if constexpr(std::is_same<char_t, xtd::char32>::value) chars_ = str.chars_;
2426 else chars_ = __xtd_convert_to_string<value_type>(str.chars());
2432 basic_string& operator =(
const basic_string<xtd::char8>& str)
noexcept {
2433 if constexpr(std::is_same<char_t, xtd::char8>::value) chars_ = str.chars_;
2434 else chars_ = __xtd_convert_to_string<value_type>(str.chars());
2440 basic_string& operator =(
const basic_string<xtd::wchar>& str)
noexcept {
2441 if constexpr(std::is_same<char_t, xtd::wchar>::value) chars_ = str.chars_;
2442 else chars_ = __xtd_convert_to_string<value_type>(str.chars());
2449 basic_string& operator =(basic_string<char>&& str)
noexcept {
2450 if constexpr(std::is_same<char_t, char>::value) chars_ = std::move(str.chars_);
2451 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str.chars_)));
2457 basic_string& operator =(basic_string<xtd::char16>&& str)
noexcept {
2458 if constexpr(std::is_same<char_t, xtd::char16>::value) chars_ = std::move(str.chars_);
2459 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str.chars_)));
2465 basic_string& operator =(basic_string<xtd::char32>&& str)
noexcept {
2466 if constexpr(std::is_same<char_t, xtd::char32>::value) chars_ = std::move(str.chars_);
2467 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str.chars_)));
2473 basic_string& operator =(basic_string<xtd::char8>&& str)
noexcept {
2474 if constexpr(std::is_same<char_t, xtd::char8>::value) chars_ = std::move(str.chars_);
2475 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str.chars_)));
2481 basic_string& operator =(basic_string<xtd::wchar>&& str)
noexcept {
2482 if constexpr(std::is_same<char_t, xtd::wchar>::value) chars_ = std::move(str.chars_);
2483 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str.chars_)));
2490 basic_string& operator =(
const std::basic_string<char>& str)
noexcept {
2491 if constexpr(std::is_same<char_t, char>::value) chars_ = str;
2492 else chars_ = __xtd_convert_to_string<value_type>(str);
2498 basic_string& operator =(
const std::basic_string<xtd::char16>& str)
noexcept {
2499 if constexpr(std::is_same<char_t, xtd::char16>::value) chars_ = str;
2500 else chars_ = __xtd_convert_to_string<value_type>(str);
2506 basic_string& operator =(
const std::basic_string<xtd::char32>& str)
noexcept {
2507 if constexpr(std::is_same<char_t, xtd::char32>::value) chars_ = str;
2508 else chars_ = __xtd_convert_to_string<value_type>(str);
2514 basic_string& operator =(
const std::basic_string<xtd::char8>& str)
noexcept {
2515 if constexpr(std::is_same<char_t, xtd::char8>::value) chars_ = str;
2516 else chars_ = __xtd_convert_to_string<value_type>(str);
2522 basic_string& operator =(
const std::basic_string<xtd::wchar>& str)
noexcept {
2523 if constexpr(std::is_same<char_t, xtd::wchar>::value) chars_ = str;
2524 else chars_ = __xtd_convert_to_string<value_type>(str);
2531 basic_string& operator =(std::basic_string<char>&& str)
noexcept {
2532 if constexpr(std::is_same<char_t, char>::value) chars_ = std::move(str);
2533 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str)));
2539 basic_string& operator =(std::basic_string<xtd::char16>&& str)
noexcept {
2540 if constexpr(std::is_same<char_t, xtd::char16>::value) chars_ = std::move(str);
2541 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str)));
2547 basic_string& operator =(std::basic_string<xtd::char32>&& str)
noexcept {
2548 if constexpr(std::is_same<char_t, xtd::char32>::value) chars_ = std::move(str);
2549 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str)));
2555 basic_string& operator =(std::basic_string<xtd::char8>&& str)
noexcept {
2556 if constexpr(std::is_same<char_t, xtd::char8>::value) chars_ = std::move(str);
2557 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str)));
2563 basic_string& operator =(std::basic_string<xtd::wchar>&& str)
noexcept {
2564 if constexpr(std::is_same<char_t, xtd::wchar>::value) chars_ = std::move(str);
2565 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str)));
2573 basic_string& operator =(
const char* str) {
2575 if constexpr(std::is_same_v<char, char_t>) chars_ = std::basic_string<char>(str);
2576 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<char>(str));
2583 basic_string& operator =(
const xtd::char16 * str) {
2585 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ = std::basic_string<xtd::char16>(str);
2586 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str));
2593 basic_string& operator =(
const xtd::char32 * str) {
2595 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ = std::basic_string<xtd::char32>(str);
2596 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str));
2603 basic_string& operator =(
const xtd::char8 * str) {
2605 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ = std::basic_string<xtd::char8>(str);
2606 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str));
2613 basic_string& operator =(
const xtd::wchar * str) {
2615 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ = std::basic_string<xtd::wchar>(str);
2616 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str));
2623 basic_string& operator =(
char character) {
2624 *
this = basic_string(1, character);
2631 *
this = basic_string(1, character);
2638 *
this = basic_string(1, character);
2644 basic_string& operator =(
xtd::char8 character) {
2645 *
this = basic_string(1, character);
2651 basic_string& operator =(
xtd::wchar character) {
2652 *
this = basic_string(1, character);
2659 basic_string& operator =(
const std::initializer_list<char>& il) {
2660 *
this = basic_string(il);
2666 basic_string& operator =(
const std::initializer_list<xtd::char16>& il) {
2667 *
this = basic_string(il);
2673 basic_string& operator =(
const std::initializer_list<xtd::char32>& il) {
2674 *
this = basic_string(il);
2680 basic_string& operator =(
const std::initializer_list<xtd::char8>& il) {
2681 *
this = basic_string(il);
2687 basic_string& operator =(
const std::initializer_list<xtd::wchar>& il) {
2688 *
this = basic_string(il);
2695 basic_string & operator +=(
const basic_string<char>& str) {
2696 if constexpr(std::is_same_v<char, char_t>) chars_ += str.chars_;
2697 else chars_ += __xtd_convert_to_string<value_type>(str.chars_);
2703 basic_string & operator +=(
const basic_string<xtd::char16>& str) {
2704 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ += str.chars_;
2705 else chars_ += __xtd_convert_to_string<value_type>(str.chars_);
2711 basic_string & operator +=(
const basic_string<xtd::char32>& str) {
2712 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ += str.chars_;
2713 else chars_ += __xtd_convert_to_string<value_type>(str.chars_);
2719 basic_string & operator +=(
const basic_string<xtd::char8>& str) {
2720 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ += str.chars_;
2721 else chars_ += __xtd_convert_to_string<value_type>(str.chars_);
2727 basic_string & operator +=(
const basic_string<xtd::wchar>& str) {
2728 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ += str.chars_;
2729 else chars_ += __xtd_convert_to_string<value_type>(str.chars_);
2736 basic_string & operator +=(basic_string<char>&& str) {
2737 if constexpr(std::is_same_v<char, char_t>) chars_ += std::move(str.chars_);
2738 else chars_ += __xtd_convert_to_string<value_type>(std::move(str.chars_));
2744 basic_string & operator +=(basic_string<xtd::char16>&& str) {
2745 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ += std::move(str.chars_);
2746 else chars_ += __xtd_convert_to_string<value_type>(std::move(str.chars_));
2752 basic_string & operator +=(basic_string<xtd::char32>&& str) {
2753 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ += std::move(str.chars_);
2754 else chars_ += __xtd_convert_to_string<value_type>(std::move(str.chars_));
2760 basic_string & operator +=(basic_string<xtd::char8>&& str) {
2761 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ += std::move(str.chars_);
2762 else chars_ += __xtd_convert_to_string<value_type>(std::move(str.chars_));
2768 basic_string & operator +=(basic_string<xtd::wchar>&& str) {
2769 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ += std::move(str.chars_);
2770 else chars_ += __xtd_convert_to_string<value_type>(std::move(str.chars_));
2777 basic_string & operator +=(
const std::basic_string<char>& str) {
2778 if constexpr(std::is_same_v<char, char_t>) chars_ += str;
2779 else chars_ += __xtd_convert_to_string<value_type>(str);
2785 basic_string & operator +=(
const std::basic_string<xtd::char16>& str) {
2786 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ += str;
2787 else chars_ += __xtd_convert_to_string<value_type>(str);
2793 basic_string & operator +=(
const std::basic_string<xtd::char32>& str) {
2794 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ += str;
2795 else chars_ += __xtd_convert_to_string<value_type>(str);
2801 basic_string & operator +=(
const std::basic_string<xtd::char8>& str) {
2802 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ += str;
2803 else chars_ += __xtd_convert_to_string<value_type>(str);
2809 basic_string & operator +=(
const std::basic_string<xtd::wchar>& str) {
2810 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ += str;
2811 else chars_ += __xtd_convert_to_string<value_type>(str);
2818 basic_string & operator +=(
const char* str) {
2819 chars_ += basic_string(str).chars_;
2825 basic_string & operator +=(
const xtd::char16 * str) {
2826 chars_.
append(basic_string(str).chars_);
return *
this;
2831 basic_string & operator +=(
const xtd::char32 * str) {
2832 chars_ += basic_string(str).chars_;
2838 basic_string & operator +=(
const xtd::char8 * str) {
2839 chars_ += basic_string(str).chars_;
2845 basic_string & operator +=(
const xtd::wchar * str) {
2846 chars_ += basic_string(str).chars_;
2852 basic_string & operator +=(
char ch) {
2853 chars_ += basic_string(1, ch).chars_;
2860 chars_ += basic_string(1, ch).chars_;
2867 chars_ += basic_string(1, ch).chars_;
2874 chars_ += basic_string(1, ch).chars_;
2881 chars_ += basic_string(1, ch).chars_;
2889 friend basic_string operator +(
const basic_string & lhs,
const basic_string<char>& rhs) {
2898 friend basic_string operator +(
const basic_string & lhs,
const basic_string<xtd::char16>& rhs) {
2907 friend basic_string operator +(
const basic_string & lhs,
const basic_string<xtd::char32>& rhs) {
2916 friend basic_string operator +(
const basic_string & lhs,
const basic_string<xtd::char8>& rhs) {
2925 friend basic_string operator +(
const basic_string & lhs,
const basic_string<xtd::wchar>& rhs) {
2935 friend basic_string operator +(basic_string&& lhs, basic_string<char>&& rhs) {
2936 auto result = std::move(lhs);
2937 result += std::move(rhs);
2944 friend basic_string operator +(basic_string&& lhs, basic_string<xtd::char16>&& rhs) {
2945 auto result = std::move(lhs);
2946 result += std::move(rhs);
2953 friend basic_string operator +(basic_string&& lhs, basic_string<xtd::char32>&& rhs) {
2954 auto result = std::move(lhs);
2955 result += std::move(rhs);
2962 friend basic_string operator +(basic_string&& lhs, basic_string<xtd::char8>&& rhs) {
2963 auto result = std::move(lhs);
2964 result += std::move(rhs);
2971 friend basic_string operator +(basic_string&& lhs, basic_string<xtd::wchar>&& rhs) {
2972 auto result = std::move(lhs);
2973 result += std::move(rhs);
2981 friend basic_string operator +(basic_string&& lhs,
const basic_string<char>& rhs) {
2982 auto result = std::move(lhs);
2990 friend basic_string operator +(basic_string&& lhs,
const basic_string<xtd::char16>& rhs) {
2991 auto result = std::move(lhs);
2999 friend basic_string operator +(basic_string&& lhs,
const basic_string<xtd::char32>& rhs) {
3000 auto result = std::move(lhs);
3008 friend basic_string operator +(basic_string&& lhs,
const basic_string<xtd::char8>& rhs) {
3009 auto result = std::move(lhs);
3017 friend basic_string operator +(basic_string&& lhs,
const basic_string<xtd::wchar>& rhs) {
3018 auto result = std::move(lhs);
3027 friend basic_string operator +(
const basic_string & lhs, basic_string<char>&& rhs) {
3029 result += std::move(rhs);
3036 friend basic_string operator +(
const basic_string & lhs, basic_string<xtd::char16>&& rhs) {
3038 result += std::move(rhs);
3045 friend basic_string operator +(
const basic_string & lhs, basic_string<xtd::char32>&& rhs) {
3047 result += std::move(rhs);
3054 friend basic_string operator +(
const basic_string & lhs, basic_string<xtd::char8>&& rhs) {
3056 result += std::move(rhs);
3063 friend basic_string operator +(
const basic_string & lhs, basic_string<xtd::wchar>&& rhs) {
3065 result += std::move(rhs);
3073 friend basic_string operator +(
const basic_string & lhs,
const std::basic_string<char>& rhs) {
3082 friend basic_string operator +(
const basic_string & lhs,
const std::basic_string<xtd::char16>& rhs) {
3091 friend basic_string operator +(
const basic_string & lhs,
const std::basic_string<xtd::char32>& rhs) {
3100 friend basic_string operator +(
const basic_string & lhs,
const std::basic_string<xtd::char8>& rhs) {
3109 friend basic_string operator +(
const basic_string & lhs,
const std::basic_string<xtd::wchar>& rhs) {
3119 friend basic_string operator +(
const std::basic_string<char>& lhs,
const basic_string & rhs) {
3121 if constexpr(std::is_same_v<char, char_t>) result += rhs.chars();
3122 else result += __xtd_convert_to_string<char>(rhs.chars());
3129 friend basic_string operator +(
const std::basic_string<xtd::char16>& lhs,
const basic_string & rhs) {
3131 if constexpr(std::is_same_v<xtd::char16, char_t>) result += rhs.chars();
3132 else result += __xtd_convert_to_string<xtd::char16>(rhs.chars());
3139 friend basic_string operator +(
const std::basic_string<xtd::char32>& lhs,
const basic_string & rhs) {
3141 if constexpr(std::is_same_v<xtd::char32, char_t>) result += rhs.chars();
3142 else result += __xtd_convert_to_string<xtd::char32>(rhs.chars());
3149 friend basic_string operator +(
const std::basic_string<xtd::char8>& lhs,
const basic_string & rhs) {
3151 if constexpr(std::is_same_v<xtd::char8, char_t>) result += rhs.chars();
3152 else result += __xtd_convert_to_string<xtd::char8>(rhs.chars());
3159 friend basic_string operator +(
const std::basic_string<xtd::wchar>& lhs,
const basic_string & rhs) {
3161 if constexpr(std::is_same_v<xtd::wchar, char_t>) result += rhs.chars();
3162 else result += __xtd_convert_to_string<xtd::wchar>(rhs.chars());
3170 friend basic_string operator +(
const basic_string & lhs,
const char* rhs) {
3179 friend basic_string operator +(
const basic_string & lhs,
const xtd::char16 * rhs) {
3188 friend basic_string operator +(
const basic_string & lhs,
const xtd::char32 * rhs) {
3197 friend basic_string operator +(
const basic_string & lhs,
const xtd::char8 * rhs) {
3206 friend basic_string operator +(
const basic_string & lhs,
const xtd::wchar * rhs) {
3216 friend basic_string operator +(basic_string&& lhs,
const char* rhs) {
3217 auto result = std::move(lhs);
3225 friend basic_string operator +(basic_string&& lhs,
const xtd::char16 * rhs) {
3226 auto result = std::move(lhs);
3234 friend basic_string operator +(basic_string&& lhs,
const xtd::char32 * rhs) {
3235 auto result = std::move(lhs);
3243 friend basic_string operator +(basic_string&& lhs,
const xtd::char8 * rhs) {
3244 auto result = std::move(lhs);
3252 friend basic_string operator +(basic_string&& lhs,
const xtd::wchar * rhs) {
3253 auto result = std::move(lhs);
3262 friend basic_string operator +(
const char* lhs,
const basic_string & rhs) {
3263 auto result = basic_string(lhs);
3271 friend basic_string operator +(
const xtd::char16 * lhs,
const basic_string & rhs) {
3272 auto result = basic_string(lhs);
3280 friend basic_string operator +(
const xtd::char32 * lhs,
const basic_string & rhs) {
3281 auto result = basic_string(lhs);
3289 friend basic_string operator +(
const xtd::char8 * lhs,
const basic_string & rhs) {
3290 auto result = basic_string(lhs);
3298 friend basic_string operator +(
const xtd::wchar * lhs,
const basic_string & rhs) {
3299 auto result = basic_string(lhs);
3308 friend basic_string operator +(
const char* lhs, basic_string&& rhs) {
3309 auto result = basic_string(lhs);
3310 result += std::move(rhs);
3317 friend basic_string operator +(
const xtd::char16 * lhs, basic_string&& rhs) {
3318 auto result = basic_string(lhs);
3319 result += std::move(rhs);
3326 friend basic_string operator +(
const xtd::char32 * lhs, basic_string&& rhs) {
3327 auto result = basic_string(lhs);
3328 result += std::move(rhs);
3335 friend basic_string operator +(
const xtd::char8 * lhs, basic_string&& rhs) {
3336 auto result = basic_string(lhs);
3337 result += std::move(rhs);
3344 friend basic_string operator +(
const xtd::wchar * lhs, basic_string&& rhs) {
3345 auto result = basic_string(lhs);
3346 result += std::move(rhs);
3354 friend basic_string operator +(
const basic_string & lhs,
const char rhs) {
3363 friend basic_string operator +(
const basic_string & lhs,
const xtd::char16 rhs) {
3372 friend basic_string operator +(
const basic_string & lhs,
const xtd::char32 rhs) {
3381 friend basic_string operator +(
const basic_string & lhs,
const xtd::char8 rhs) {
3390 friend basic_string operator +(
const basic_string & lhs,
const xtd::wchar rhs) {
3400 friend basic_string operator +(basic_string&& lhs,
const char rhs) {
3401 auto result = std::move(lhs);
3409 friend basic_string operator +(basic_string&& lhs,
const xtd::char16 rhs) {
3410 auto result = std::move(lhs);
3418 friend basic_string operator +(basic_string&& lhs,
const xtd::char32 rhs) {
3419 auto result = std::move(lhs);
3427 friend basic_string operator +(basic_string&& lhs,
const xtd::char8 rhs) {
3428 auto result = std::move(lhs);
3436 friend basic_string operator +(basic_string&& lhs,
const xtd::wchar rhs) {
3437 auto result = std::move(lhs);
3446 friend basic_string operator +(
char lhs,
const basic_string & rhs) {
3447 auto result = basic_string(1, lhs);
3455 friend basic_string operator +(
xtd::char16 lhs,
const basic_string & rhs) {
3456 auto result = basic_string(1, lhs);
3464 friend basic_string operator +(
xtd::char32 lhs,
const basic_string & rhs) {
3465 auto result = basic_string(1, lhs);
3473 friend basic_string operator +(
xtd::char8 lhs,
const basic_string & rhs) {
3474 auto result = basic_string(1, lhs);
3482 friend basic_string operator +(
xtd::wchar lhs,
const basic_string & rhs) {
3483 auto result = basic_string(1, lhs);
3492 friend basic_string operator +(
char lhs, basic_string&& rhs) {
3493 auto result = basic_string(1, lhs);
3494 result += std::move(rhs);
3501 friend basic_string operator +(
xtd::char16 lhs, basic_string&& rhs) {
3502 auto result = basic_string(1, lhs);
3503 result += std::move(rhs);
3510 friend basic_string operator +(
xtd::char32 lhs, basic_string&& rhs) {
3511 auto result = basic_string(1, lhs);
3512 result += std::move(rhs);
3519 friend basic_string operator +(
xtd::char8 lhs, basic_string&& rhs) {
3520 auto result = basic_string(1, lhs);
3521 result += std::move(rhs);
3528 friend basic_string operator +(
xtd::wchar lhs, basic_string&& rhs) {
3529 auto result = basic_string(1, lhs);
3530 result += std::move(rhs);
3543 friend std::basic_ostream<char>& operator <<(std::basic_ostream<char>& stream,
const basic_string & str) {
3544 if constexpr(std::is_same_v<char, char_t>)
return stream << str.chars();
3545 else return stream << __xtd_convert_to_string<char>(str.chars());
3553 friend std::basic_ostream<xtd::wchar>& operator <<(std::basic_ostream<xtd::wchar>& stream,
const basic_string & str) {
return stream << str.to_wstring().chars();}
3563 friend std::basic_istream<char>& operator >>(std::basic_istream<char>& stream, basic_string & str) {
3564 auto s = std::basic_string<char> {};
3577 friend std::basic_istream<xtd::wchar>& operator >>(std::basic_istream<xtd::wchar>& stream, basic_string & str) {
3578 auto s = std::basic_string<xtd::wchar> {};
3586 friend class basic_string<char>;
3587 friend class basic_string<xtd::
char16>;
3588 friend class basic_string<xtd::char32>;
3589 friend class basic_string<xtd::char8>;
3590 friend class basic_string<xtd::wchar>;
3592 static const xtd::array<value_type> default_split_separators;
3593 static const xtd::array<value_type> default_trim_chars;
3595 template<class arg_t>
3596 static auto convert_param(arg_t&& arg) noexcept {
3597 if constexpr(std::is_same<std::remove_cv_t<std::remove_reference_t<arg_t>>, std::string>::value)
return std::forward<arg_t>(arg).c_str();
3598 else if constexpr(std::is_same<std::remove_cv_t<std::remove_reference_t<arg_t>>, std::u16string>::value)
return std::forward<arg_t>(arg).c_str();
3599 else if constexpr(std::is_same<std::remove_cv_t<std::remove_reference_t<arg_t>>, std::u32string>::value)
return std::forward<arg_t>(arg).c_str();
3600 else if constexpr(std::is_same<std::remove_cv_t<std::remove_reference_t<arg_t>>, std::u8string>::value)
return std::forward<arg_t>(arg).c_str();
3601 else if constexpr(std::is_same<std::remove_cv_t<std::remove_reference_t<arg_t>>, std::wstring>::value)
return std::forward<arg_t>(arg).c_str();
3602 else if constexpr(std::is_same<std::remove_cv_t<std::remove_reference_t<arg_t>>, basic_string>::value)
return std::forward<arg_t>(arg).c_str();
3603 else return std::forward<arg_t>(arg);
3606 static basic_string get_class_name(
const basic_string & full_name) {
3607 auto length = full_name.last_index_of(
"<");
3609 if (full_name.last_index_of(
"::", 0,
length) == npos)
return full_name;
3610 return full_name.substring(full_name.last_index_of(
"::", 0,
length) + 2);
3613 typename base_type::iterator to_base_type_iterator(
iterator value)
const noexcept {
3614 if (value ==
begin())
return chars_.begin();
3615 if (value ==
end())
return chars_.end();
3616 return chars_.begin() + (value -
begin());
3619 iterator to_iterator(
typename base_type::iterator value)
const noexcept {
3620 if (value == chars_.begin())
return begin();
3621 if (value == chars_.end())
return end();
3622 return begin() + (value - chars_.begin());