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_;}
851 const_reverse_iterator
crend()
const {
return chars_.crend();}
860 const_pointer
data()
const noexcept {
return chars_.data();}
864 bool empty()
const noexcept {
return chars_.empty();}
878 size_type
length()
const noexcept {
return chars_.size();}
882 size_type max_size()
const noexcept {
return chars_.max_size();}
886 const_reverse_iterator
rbegin()
const {
return chars_.crbegin();}
890 const_reverse_iterator
rend()
const {
return chars_.crend();}
894 size_type
size()
const noexcept {
return chars_.size();}
903 const_reference
at(size_type pos)
const {
return operator [](pos);}
945 int32 compare(size_type pos1, size_type count1,
const basic_string & str)
const {
return chars_.compare(pos1, count1, str);}
969 int32 compare(size_type pos1, size_type count1,
const basic_string & str, size_type pos2)
const {
return chars_.compare(pos1, count1, str, pos2);}
994 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);}
1013 int32 compare(const_pointer
s)
const {
return chars_.compare(
s);}
1035 int32 compare(size_type pos1, size_type count1, const_pointer
s)
const {
return chars_.compare(pos1, count1,
s);}
1058 int32 compare(size_type pos1, size_type count1, const_pointer
s, size_type count2)
const {
return chars_.compare(pos1, count1,
s, count2);}
1107 if (ignore_case)
return to_upper().chars_ == value.to_upper().chars_;
1108 return chars_ == value.chars_;
1120 if (ignore_case)
return to_lower().rfind(
static_cast<value_type>(tolower(value))) ==
size() - 1;
1138 return rfind(value) + value.size() ==
size();
1158 size_type
find(const_pointer
s, size_type pos, size_type
count)
const {
return chars_.find(
s, pos,
count);}
1164 size_type
find(const_pointer
s)
const {
return chars_.find(
s);}
1171 size_type
find(const_pointer
s, size_type pos)
const {
return chars_.find(
s, pos);}
1215 size_type
find_first_of(const_pointer
s, size_type pos)
const {
return chars_.find_first_of(
s, pos);}
1226 size_type
find_first_of(char_t ch, size_type pos)
const {
return chars_.find_first_of(ch, pos);}
1270 size_type
find_first_not_of(char_t ch, size_type pos)
const {
return chars_.find_first_not_of(ch, pos);}
1303 size_type
find_last_of(const_pointer
s, size_type pos)
const {
return chars_.find_last_of(
s, pos);}
1314 size_type
find_last_of(char_t ch, size_type pos)
const {
return chars_.find_last_of(ch, pos);}
1347 size_type
find_last_not_of(const_pointer
s, size_type pos)
const {
return chars_.find_last_not_of(
s, pos);}
1358 size_type
find_last_not_of(char_t ch, size_type pos)
const {
return chars_.find_last_not_of(ch, pos);}
1375 explicit basic_string_enumerator(
const basic_string & chars) : chars_(chars) {}
1377 const value_type & current()
const override {
return chars_[index_];}
1379 bool move_next()
override {
return ++index_ < chars_.size();}
1381 void reset()
override {index_ = basic_string::npos;}
1407 auto result =
find(value, start_index);
1408 return result > start_index +
count ? npos : result;
1427 auto result =
find(value, start_index);
1428 return result > start_index +
count ? npos : result;
1462 auto result = *
this;
1463 result.chars_.insert(start_index, value);
1470 [[deprecated(
"Replaced by xtd::basic_string::is_empty(const xtd::basic_string&) - Will be removed in version 0.4.0.")]]
1491 auto result =
rfind(value, start_index +
count - value.size());
1492 return result < start_index ? npos : result;
1513 auto result =
rfind(value, start_index +
count - 1);
1514 return result < start_index ? npos : result;
1582 std::wstringstream ss;
1583 if constexpr(std::is_same_v<xtd::wchar, value_type>) ss << std::quoted(chars_, delimiter,
escape);
1584 else ss << std::quoted(__xtd_convert_to_string<xtd::wchar>(chars_),
static_cast<xtd::wchar>(delimiter),
static_cast<xtd::wchar>(
escape));
1598 auto result = *
this;
1599 result.chars_.erase(start_index,
count);
1614 auto result = *
this;
1615 auto old_size = old_string.size();
1616 auto new_size = new_string.size();
1619 index = result.find(old_string, index);
1620 if (index == npos)
break;
1621 if (old_size == new_size) result.chars_.replace(index, old_size, new_string);
1623 result.chars_.erase(index, old_string.size());
1624 result.chars_.insert(index, new_string);
1626 index += new_string.size();
1640 size_type
rfind(
const basic_string & str, size_type pos)
const {
return chars_.rfind(str, pos);}
1654 size_type
rfind(const_pointer
s)
const {
return chars_.rfind(
s);}
1661 size_type
rfind(const_pointer
s, size_type pos)
const {
return chars_.rfind(
s, pos);}
1672 size_type
rfind(
value_type ch, size_type pos)
const {
return chars_.rfind(ch, pos);}
1678 xtd::array<basic_string> split() const noexcept;
1728 xtd::array<basic_string> split(const xtd::array<
value_type>& separators) const noexcept;
1754 xtd::array<basic_string> split(const xtd::array<
value_type>& separators, xtd::
size count) const noexcept;
1772 bool starts_with(
value_type value) const noexcept {
return starts_with(value,
false);}
1778 bool starts_with(
value_type value,
bool ignore_case)
const noexcept {
1779 if (ignore_case)
return to_lower().find(
static_cast<value_type>(tolower(value))) == 0;
1780 return find(value) == 0;
1799 return find(value) == 0;
1806 basic_string substr()
const {
return chars_.substr();}
1812 basic_string substr(size_type pos)
const {
1814 return chars_.substr(pos);
1822 basic_string substr(size_type pos, size_type
count)
const {
1824 return chars_.substr(pos,
count);
1832 basic_string substring(
xtd::size start_index)
const {
1834 return substr(start_index);
1843 return substr(start_index,
length);
1848 xtd::array<value_type>
to_array() const noexcept;
1861 xtd::array<
value_type> to_char_array() const noexcept;
1870 basic_string to_lower() const noexcept {
1871 auto result = basic_string::empty_string;
1872 std::for_each(chars_.begin(), chars_.end(), [&](
auto c) {result += static_cast<value_type>(std::tolower(c));});
1879 basic_string<char>
to_string() const noexcept
override {
1880 if constexpr(std::is_same_v<char, char_t>)
return chars_;
1881 else return __xtd_convert_to_string<char>(chars_);
1886 basic_string to_title_case() const noexcept;
1890 basic_string<xtd::
char16> to_u16string() const noexcept {
1891 if constexpr(std::is_same_v<xtd::char16, char_t>)
return chars_;
1892 else return __xtd_convert_to_string<xtd::char16>(chars_);
1897 basic_string<xtd::char32> to_u32string() const noexcept {
1898 if constexpr(std::is_same_v<xtd::char32, char_t>)
return chars_;
1899 else return __xtd_convert_to_string<xtd::char32>(chars_);
1904 basic_string<xtd::char8> to_u8string() const noexcept {
1905 if constexpr(std::is_same_v<xtd::char8, char_t>)
return chars_;
1906 else return __xtd_convert_to_string<xtd::char8>(chars_);
1911 basic_string to_upper() const noexcept {
1912 auto result = basic_string::empty_string;
1913 std::for_each(chars_.begin(), chars_.end(), [&](
auto c) {result += static_cast<value_type>(std::toupper(c));});
1919 basic_string<xtd::wchar> to_wstring() const noexcept {
1920 if constexpr(std::is_same_v<xtd::wchar, char_t>)
return chars_;
1921 else return __xtd_convert_to_string<xtd::wchar>(chars_);
1928 basic_string trim() const noexcept {
return trim(default_trim_chars);}
1933 basic_string trim(
value_type trim_char)
const noexcept;
1938 basic_string trim(
const xtd::array<value_type>& trim_chars)
const noexcept;
1944 basic_string trim_end() const noexcept {
return trim_end(default_trim_chars);}
1949 basic_string trim_end(
value_type trim_char)
const noexcept;
1954 basic_string trim_end(
const xtd::array<value_type>& trim_chars)
const noexcept;
1960 basic_string trim_start() const noexcept {
return trim_start(default_trim_chars);}
1965 basic_string trim_start(
value_type trim_char)
const noexcept;
1970 basic_string trim_start(
const xtd::array<value_type>& trim_chars)
const noexcept;
1980 template<
class object_t>
1981 [[deprecated(
"Replaced by typeof_<object_t>().name() - Will be removed in version 0.4.0.")]]
1982 static basic_string class_name() {
return get_class_name(full_class_name<object_t>());}
1987 template<
class object_t>
1988 [[deprecated(
"Replaced by typeof_(object).name() - Will be removed in version 0.4.0.")]]
1989 static basic_string class_name(
const object_t&
object) {
return get_class_name(full_class_name(
object));}
1994 [[deprecated(
"Replaced by typeof_(info).name() - Will be removed in version 0.4.0.")]]
1995 static basic_string class_name(
const std::type_info & info) {
return __xtd_get_class_name(info);}
2006 static int32 compare(
const basic_string & str_a,
const basic_string & str_b)
noexcept {
return compare(str_a, str_b,
false);}
2055 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);}
2077 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;}
2084 template<
class object_a_t,
class object_b_t,
class object_c_t,
class object_d_t>
2085 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);}
2091 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;}
2097 template<
class object_a_t,
class object_b_t,
class object_c_t>
2098 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);}
2103 static basic_string
concat(
const basic_string & str_a,
const basic_string & str_b)
noexcept {
return str_a + str_b;}
2108 template<
class object_a_t,
class object_b_t>
2109 static basic_string
concat(object_a_t obj_a, object_b_t obj_b)
noexcept {
return format(
"{}{}", obj_a, obj_b);}
2113 static basic_string
concat(
const xtd::array<basic_string>& values)
noexcept;
2115 static basic_string
concat(
const xtd::array<const_pointer>& values)
noexcept;
2116 template<
class other_
char_t>
2117 static basic_string
concat(
const xtd::array<const other_char_t*>& values)
noexcept;
2118 static basic_string
concat(
const std::initializer_list<basic_string>& values)
noexcept {
2119 auto result = basic_string::empty_string;
2120 std::for_each(values.begin(), values.end(), [&](
const auto & item) {result += item;});
2123 static basic_string
concat(
const std::initializer_list<const_pointer>& values)
noexcept {
2124 auto result = basic_string::empty_string;
2125 std::for_each(values.begin(), values.end(), [&](
const auto & item) {result += item;});
2128 template<
class other_
char_t>
2129 static basic_string
concat(
const std::initializer_list<const other_char_t*>& values)
noexcept {
2130 auto result = basic_string::empty_string;
2131 std::for_each(values.begin(), values.end(), [&](
const auto & item) {result += item;});
2138 template<
class object_t>
2139 static basic_string
concat(
const xtd::array<object_t>& args)
noexcept;
2141 template<
class object_t>
2142 static basic_string
concat(
const std::initializer_list<object_t>& args)
noexcept {
2143 basic_string result;
2144 for (
const auto& arg : args)
2145 result +=
format(
"{}", arg);
2152 template<
class value_t>
2153 static basic_string
concat(value_t value)
noexcept {
2154 return format(
"{}", value);
2177 static basic_string demangle(
const basic_string & name) {
2178 if constexpr(std::is_same_v<char, char_t>)
return __xtd_demangle(
name.chars());
2179 else return __xtd_demangle(__xtd_convert_to_string<char>(
name.chars()));
2187 static bool equals(
const basic_string &
a,
const basic_string &
b)
noexcept{
return a.equals(
b);}
2193 template<
class char_a_t,
class char_b_t>
2194 static bool equals(
const char_a_t*
a,
const char_b_t*
b)
noexcept{
return basic_string {
a}.
equals(basic_string {
b});}
2202 static bool equals(
const basic_string &
a,
const basic_string &
b,
bool ignore_case)
noexcept {
return a.equals(
b, ignore_case);}
2209 template<
class char_a_t,
class char_b_t>
2210 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);}
2218 template<
class ...args_t>
2219 static basic_string
format(
const basic_string<char>& fmt, args_t&& ... args);
2225 template<
class object_t>
2226 [[deprecated(
"Replaced by typeof_<object_t>().full_name() - Will be removed in version 0.4.0.")]]
2227 static basic_string full_class_name() {
return demangle(
typeid(object_t).
name());}
2232 template<
class object_t>
2233 [[deprecated(
"Replaced by typeof_(object).full_name() - Will be removed in version 0.4.0.")]]
2234 static basic_string full_class_name(
const object_t&
object) {
return demangle(
typeid(
object).
name());}
2239 [[deprecated(
"Replaced by typeof_(info).full_name() - Will be removed in version 0.4.0.")]]
2240 static basic_string full_class_name(
const std::type_info & info) {
return __xtd_get_full_class_name(info);}
2245 static bool is_empty(
const xtd::basic_string<value_type, traits_type, allocator_type>&
string)
noexcept {
return !
string.length();}
2253 template<
class collection_t>
2254 static basic_string join(
const basic_string
separator,
const collection_t& values)
noexcept {
2256 basic_string result;
2257 for (
const auto& item : values)
2268 template<
class collection_t>
2269 static basic_string join(
const basic_string &
separator,
const collection_t& values,
xtd::size index) {
return join(
separator, values, index, values.size() - index);}
2278 template<
class collection_t>
2282 basic_string result;
2283 for (
const auto& item : values) {
2284 if (
i >= index) result +=
format(
"{}{}", (
i != index ?
separator : basic_string {}), item);
2285 if (++
i >= index +
count)
break;
2291 template<
class value_t>
2292 static basic_string join(
const basic_string &
separator,
const std::initializer_list<value_t>& values)
noexcept;
2293 template<
class value_t>
2294 static basic_string join(
const basic_string &
separator,
const std::initializer_list<value_t>& values,
xtd::size index);
2295 template<
class value_t>
2302 template<
class value_t>
2303 static value_t
parse(
const basic_string & str) {
2367 template<
class ...args_t>
2368 static basic_string
sprintf(
const basic_string & fmt, args_t&& ... args)
noexcept {
return __sprintf(fmt.c_str(), convert_param(std::forward<args_t>(args)) ...);}
2374 template<
class value_t>
2375 static bool try_parse(
const basic_string & str, value_t& value)
noexcept {
2394 return chars_[index];
2399 operator const base_type & ()
const noexcept {
return chars_;}
2404 basic_string& operator =(
const basic_string<char>& str)
noexcept {
2405 if constexpr(std::is_same<char_t, char>::value) chars_ = str.chars_;
2406 else chars_ = __xtd_convert_to_string<value_type>(str.chars());
2412 basic_string& operator =(
const basic_string<xtd::char16>& str)
noexcept {
2413 if constexpr(std::is_same<char_t, xtd::char16>::value) chars_ = str.chars_;
2414 else chars_ = __xtd_convert_to_string<value_type>(str.chars());
2420 basic_string& operator =(
const basic_string<xtd::char32>& str)
noexcept {
2421 if constexpr(std::is_same<char_t, xtd::char32>::value) chars_ = str.chars_;
2422 else chars_ = __xtd_convert_to_string<value_type>(str.chars());
2428 basic_string& operator =(
const basic_string<xtd::char8>& str)
noexcept {
2429 if constexpr(std::is_same<char_t, xtd::char8>::value) chars_ = str.chars_;
2430 else chars_ = __xtd_convert_to_string<value_type>(str.chars());
2436 basic_string& operator =(
const basic_string<xtd::wchar>& str)
noexcept {
2437 if constexpr(std::is_same<char_t, xtd::wchar>::value) chars_ = str.chars_;
2438 else chars_ = __xtd_convert_to_string<value_type>(str.chars());
2445 basic_string& operator =(basic_string<char>&& str)
noexcept {
2446 if constexpr(std::is_same<char_t, char>::value) chars_ = std::move(str.chars_);
2447 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str.chars_)));
2453 basic_string& operator =(basic_string<xtd::char16>&& str)
noexcept {
2454 if constexpr(std::is_same<char_t, xtd::char16>::value) chars_ = std::move(str.chars_);
2455 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str.chars_)));
2461 basic_string& operator =(basic_string<xtd::char32>&& str)
noexcept {
2462 if constexpr(std::is_same<char_t, xtd::char32>::value) chars_ = std::move(str.chars_);
2463 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str.chars_)));
2469 basic_string& operator =(basic_string<xtd::char8>&& str)
noexcept {
2470 if constexpr(std::is_same<char_t, xtd::char8>::value) chars_ = std::move(str.chars_);
2471 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str.chars_)));
2477 basic_string& operator =(basic_string<xtd::wchar>&& str)
noexcept {
2478 if constexpr(std::is_same<char_t, xtd::wchar>::value) chars_ = std::move(str.chars_);
2479 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str.chars_)));
2486 basic_string& operator =(
const std::basic_string<char>& str)
noexcept {
2487 if constexpr(std::is_same<char_t, char>::value) chars_ = str;
2488 else chars_ = __xtd_convert_to_string<value_type>(str);
2494 basic_string& operator =(
const std::basic_string<xtd::char16>& str)
noexcept {
2495 if constexpr(std::is_same<char_t, xtd::char16>::value) chars_ = str;
2496 else chars_ = __xtd_convert_to_string<value_type>(str);
2502 basic_string& operator =(
const std::basic_string<xtd::char32>& str)
noexcept {
2503 if constexpr(std::is_same<char_t, xtd::char32>::value) chars_ = str;
2504 else chars_ = __xtd_convert_to_string<value_type>(str);
2510 basic_string& operator =(
const std::basic_string<xtd::char8>& str)
noexcept {
2511 if constexpr(std::is_same<char_t, xtd::char8>::value) chars_ = str;
2512 else chars_ = __xtd_convert_to_string<value_type>(str);
2518 basic_string& operator =(
const std::basic_string<xtd::wchar>& str)
noexcept {
2519 if constexpr(std::is_same<char_t, xtd::wchar>::value) chars_ = str;
2520 else chars_ = __xtd_convert_to_string<value_type>(str);
2527 basic_string& operator =(std::basic_string<char>&& str)
noexcept {
2528 if constexpr(std::is_same<char_t, char>::value) chars_ = std::move(str);
2529 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str)));
2535 basic_string& operator =(std::basic_string<xtd::char16>&& str)
noexcept {
2536 if constexpr(std::is_same<char_t, xtd::char16>::value) chars_ = std::move(str);
2537 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str)));
2543 basic_string& operator =(std::basic_string<xtd::char32>&& str)
noexcept {
2544 if constexpr(std::is_same<char_t, xtd::char32>::value) chars_ = std::move(str);
2545 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str)));
2551 basic_string& operator =(std::basic_string<xtd::char8>&& str)
noexcept {
2552 if constexpr(std::is_same<char_t, xtd::char8>::value) chars_ = std::move(str);
2553 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str)));
2559 basic_string& operator =(std::basic_string<xtd::wchar>&& str)
noexcept {
2560 if constexpr(std::is_same<char_t, xtd::wchar>::value) chars_ = std::move(str);
2561 else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str)));
2569 basic_string& operator =(
const char* str) {
2571 if constexpr(std::is_same_v<char, char_t>) chars_ = std::basic_string<char>(str);
2572 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<char>(str));
2579 basic_string& operator =(
const xtd::char16 * str) {
2581 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ = std::basic_string<xtd::char16>(str);
2582 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str));
2589 basic_string& operator =(
const xtd::char32 * str) {
2591 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ = std::basic_string<xtd::char32>(str);
2592 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str));
2599 basic_string& operator =(
const xtd::char8 * str) {
2601 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ = std::basic_string<xtd::char8>(str);
2602 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str));
2609 basic_string& operator =(
const xtd::wchar * str) {
2611 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ = std::basic_string<xtd::wchar>(str);
2612 else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str));
2619 basic_string& operator =(
char character) {
2620 *
this = basic_string(1, character);
2627 *
this = basic_string(1, character);
2634 *
this = basic_string(1, character);
2640 basic_string& operator =(
xtd::char8 character) {
2641 *
this = basic_string(1, character);
2647 basic_string& operator =(
xtd::wchar character) {
2648 *
this = basic_string(1, character);
2655 basic_string& operator =(
const std::initializer_list<char>& il) {
2656 *
this = basic_string(il);
2662 basic_string& operator =(
const std::initializer_list<xtd::char16>& il) {
2663 *
this = basic_string(il);
2669 basic_string& operator =(
const std::initializer_list<xtd::char32>& il) {
2670 *
this = basic_string(il);
2676 basic_string& operator =(
const std::initializer_list<xtd::char8>& il) {
2677 *
this = basic_string(il);
2683 basic_string& operator =(
const std::initializer_list<xtd::wchar>& il) {
2684 *
this = basic_string(il);
2691 basic_string & operator +=(
const basic_string<char>& str) {
2692 if constexpr(std::is_same_v<char, char_t>) chars_ += str.chars_;
2693 else chars_ += __xtd_convert_to_string<value_type>(str.chars_);
2699 basic_string & operator +=(
const basic_string<xtd::char16>& str) {
2700 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ += str.chars_;
2701 else chars_ += __xtd_convert_to_string<value_type>(str.chars_);
2707 basic_string & operator +=(
const basic_string<xtd::char32>& str) {
2708 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ += str.chars_;
2709 else chars_ += __xtd_convert_to_string<value_type>(str.chars_);
2715 basic_string & operator +=(
const basic_string<xtd::char8>& str) {
2716 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ += str.chars_;
2717 else chars_ += __xtd_convert_to_string<value_type>(str.chars_);
2723 basic_string & operator +=(
const basic_string<xtd::wchar>& str) {
2724 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ += str.chars_;
2725 else chars_ += __xtd_convert_to_string<value_type>(str.chars_);
2732 basic_string & operator +=(basic_string<char>&& str) {
2733 if constexpr(std::is_same_v<char, char_t>) chars_ += std::move(str.chars_);
2734 else chars_ += __xtd_convert_to_string<value_type>(std::move(str.chars_));
2740 basic_string & operator +=(basic_string<xtd::char16>&& str) {
2741 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ += std::move(str.chars_);
2742 else chars_ += __xtd_convert_to_string<value_type>(std::move(str.chars_));
2748 basic_string & operator +=(basic_string<xtd::char32>&& str) {
2749 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ += std::move(str.chars_);
2750 else chars_ += __xtd_convert_to_string<value_type>(std::move(str.chars_));
2756 basic_string & operator +=(basic_string<xtd::char8>&& str) {
2757 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ += std::move(str.chars_);
2758 else chars_ += __xtd_convert_to_string<value_type>(std::move(str.chars_));
2764 basic_string & operator +=(basic_string<xtd::wchar>&& str) {
2765 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ += std::move(str.chars_);
2766 else chars_ += __xtd_convert_to_string<value_type>(std::move(str.chars_));
2773 basic_string & operator +=(
const std::basic_string<char>& str) {
2774 if constexpr(std::is_same_v<char, char_t>) chars_ += str;
2775 else chars_ += __xtd_convert_to_string<value_type>(str);
2781 basic_string & operator +=(
const std::basic_string<xtd::char16>& str) {
2782 if constexpr(std::is_same_v<xtd::char16, char_t>) chars_ += str;
2783 else chars_ += __xtd_convert_to_string<value_type>(str);
2789 basic_string & operator +=(
const std::basic_string<xtd::char32>& str) {
2790 if constexpr(std::is_same_v<xtd::char32, char_t>) chars_ += str;
2791 else chars_ += __xtd_convert_to_string<value_type>(str);
2797 basic_string & operator +=(
const std::basic_string<xtd::char8>& str) {
2798 if constexpr(std::is_same_v<xtd::char8, char_t>) chars_ += str;
2799 else chars_ += __xtd_convert_to_string<value_type>(str);
2805 basic_string & operator +=(
const std::basic_string<xtd::wchar>& str) {
2806 if constexpr(std::is_same_v<xtd::wchar, char_t>) chars_ += str;
2807 else chars_ += __xtd_convert_to_string<value_type>(str);
2814 basic_string & operator +=(
const char* str) {
2815 chars_ += basic_string(str).chars_;
2821 basic_string & operator +=(
const xtd::char16 * str) {
2822 chars_.
append(basic_string(str).chars_);
return *
this;
2827 basic_string & operator +=(
const xtd::char32 * str) {
2828 chars_ += basic_string(str).chars_;
2834 basic_string & operator +=(
const xtd::char8 * str) {
2835 chars_ += basic_string(str).chars_;
2841 basic_string & operator +=(
const xtd::wchar * str) {
2842 chars_ += basic_string(str).chars_;
2848 basic_string & operator +=(
char ch) {
2849 chars_ += basic_string(1, ch).chars_;
2856 chars_ += basic_string(1, ch).chars_;
2863 chars_ += basic_string(1, ch).chars_;
2870 chars_ += basic_string(1, ch).chars_;
2877 chars_ += basic_string(1, ch).chars_;
2885 friend basic_string operator +(
const basic_string & lhs,
const basic_string<char>& rhs) {
2894 friend basic_string operator +(
const basic_string & lhs,
const basic_string<xtd::char16>& rhs) {
2903 friend basic_string operator +(
const basic_string & lhs,
const basic_string<xtd::char32>& rhs) {
2912 friend basic_string operator +(
const basic_string & lhs,
const basic_string<xtd::char8>& rhs) {
2921 friend basic_string operator +(
const basic_string & lhs,
const basic_string<xtd::wchar>& rhs) {
2931 friend basic_string operator +(basic_string&& lhs, basic_string<char>&& rhs) {
2932 auto result = std::move(lhs);
2933 result += std::move(rhs);
2940 friend basic_string operator +(basic_string&& lhs, basic_string<xtd::char16>&& rhs) {
2941 auto result = std::move(lhs);
2942 result += std::move(rhs);
2949 friend basic_string operator +(basic_string&& lhs, basic_string<xtd::char32>&& rhs) {
2950 auto result = std::move(lhs);
2951 result += std::move(rhs);
2958 friend basic_string operator +(basic_string&& lhs, basic_string<xtd::char8>&& rhs) {
2959 auto result = std::move(lhs);
2960 result += std::move(rhs);
2967 friend basic_string operator +(basic_string&& lhs, basic_string<xtd::wchar>&& rhs) {
2968 auto result = std::move(lhs);
2969 result += std::move(rhs);
2977 friend basic_string operator +(basic_string&& lhs,
const basic_string<char>& rhs) {
2978 auto result = std::move(lhs);
2986 friend basic_string operator +(basic_string&& lhs,
const basic_string<xtd::char16>& rhs) {
2987 auto result = std::move(lhs);
2995 friend basic_string operator +(basic_string&& lhs,
const basic_string<xtd::char32>& rhs) {
2996 auto result = std::move(lhs);
3004 friend basic_string operator +(basic_string&& lhs,
const basic_string<xtd::char8>& rhs) {
3005 auto result = std::move(lhs);
3013 friend basic_string operator +(basic_string&& lhs,
const basic_string<xtd::wchar>& rhs) {
3014 auto result = std::move(lhs);
3023 friend basic_string operator +(
const basic_string & lhs, basic_string<char>&& rhs) {
3025 result += std::move(rhs);
3032 friend basic_string operator +(
const basic_string & lhs, basic_string<xtd::char16>&& rhs) {
3034 result += std::move(rhs);
3041 friend basic_string operator +(
const basic_string & lhs, basic_string<xtd::char32>&& rhs) {
3043 result += std::move(rhs);
3050 friend basic_string operator +(
const basic_string & lhs, basic_string<xtd::char8>&& rhs) {
3052 result += std::move(rhs);
3059 friend basic_string operator +(
const basic_string & lhs, basic_string<xtd::wchar>&& rhs) {
3061 result += std::move(rhs);
3069 friend basic_string operator +(
const basic_string & lhs,
const std::basic_string<char>& rhs) {
3078 friend basic_string operator +(
const basic_string & lhs,
const std::basic_string<xtd::char16>& rhs) {
3087 friend basic_string operator +(
const basic_string & lhs,
const std::basic_string<xtd::char32>& rhs) {
3096 friend basic_string operator +(
const basic_string & lhs,
const std::basic_string<xtd::char8>& rhs) {
3105 friend basic_string operator +(
const basic_string & lhs,
const std::basic_string<xtd::wchar>& rhs) {
3115 friend basic_string operator +(
const std::basic_string<char>& lhs,
const basic_string & rhs) {
3117 if constexpr(std::is_same_v<char, char_t>) result += rhs.chars();
3118 else result += __xtd_convert_to_string<char>(rhs.chars());
3125 friend basic_string operator +(
const std::basic_string<xtd::char16>& lhs,
const basic_string & rhs) {
3127 if constexpr(std::is_same_v<xtd::char16, char_t>) result += rhs.chars();
3128 else result += __xtd_convert_to_string<xtd::char16>(rhs.chars());
3135 friend basic_string operator +(
const std::basic_string<xtd::char32>& lhs,
const basic_string & rhs) {
3137 if constexpr(std::is_same_v<xtd::char32, char_t>) result += rhs.chars();
3138 else result += __xtd_convert_to_string<xtd::char32>(rhs.chars());
3145 friend basic_string operator +(
const std::basic_string<xtd::char8>& lhs,
const basic_string & rhs) {
3147 if constexpr(std::is_same_v<xtd::char8, char_t>) result += rhs.chars();
3148 else result += __xtd_convert_to_string<xtd::char8>(rhs.chars());
3155 friend basic_string operator +(
const std::basic_string<xtd::wchar>& lhs,
const basic_string & rhs) {
3157 if constexpr(std::is_same_v<xtd::wchar, char_t>) result += rhs.chars();
3158 else result += __xtd_convert_to_string<xtd::wchar>(rhs.chars());
3166 friend basic_string operator +(
const basic_string & lhs,
const char* rhs) {
3175 friend basic_string operator +(
const basic_string & lhs,
const xtd::char16 * rhs) {
3184 friend basic_string operator +(
const basic_string & lhs,
const xtd::char32 * rhs) {
3193 friend basic_string operator +(
const basic_string & lhs,
const xtd::char8 * rhs) {
3202 friend basic_string operator +(
const basic_string & lhs,
const xtd::wchar * rhs) {
3212 friend basic_string operator +(basic_string&& lhs,
const char* rhs) {
3213 auto result = std::move(lhs);
3221 friend basic_string operator +(basic_string&& lhs,
const xtd::char16 * rhs) {
3222 auto result = std::move(lhs);
3230 friend basic_string operator +(basic_string&& lhs,
const xtd::char32 * rhs) {
3231 auto result = std::move(lhs);
3239 friend basic_string operator +(basic_string&& lhs,
const xtd::char8 * rhs) {
3240 auto result = std::move(lhs);
3248 friend basic_string operator +(basic_string&& lhs,
const xtd::wchar * rhs) {
3249 auto result = std::move(lhs);
3258 friend basic_string operator +(
const char* lhs,
const basic_string & rhs) {
3259 auto result = basic_string(lhs);
3267 friend basic_string operator +(
const xtd::char16 * lhs,
const basic_string & rhs) {
3268 auto result = basic_string(lhs);
3276 friend basic_string operator +(
const xtd::char32 * lhs,
const basic_string & rhs) {
3277 auto result = basic_string(lhs);
3285 friend basic_string operator +(
const xtd::char8 * lhs,
const basic_string & rhs) {
3286 auto result = basic_string(lhs);
3294 friend basic_string operator +(
const xtd::wchar * lhs,
const basic_string & rhs) {
3295 auto result = basic_string(lhs);
3304 friend basic_string operator +(
const char* lhs, basic_string&& rhs) {
3305 auto result = basic_string(lhs);
3306 result += std::move(rhs);
3313 friend basic_string operator +(
const xtd::char16 * lhs, basic_string&& rhs) {
3314 auto result = basic_string(lhs);
3315 result += std::move(rhs);
3322 friend basic_string operator +(
const xtd::char32 * lhs, basic_string&& rhs) {
3323 auto result = basic_string(lhs);
3324 result += std::move(rhs);
3331 friend basic_string operator +(
const xtd::char8 * lhs, basic_string&& rhs) {
3332 auto result = basic_string(lhs);
3333 result += std::move(rhs);
3340 friend basic_string operator +(
const xtd::wchar * lhs, basic_string&& rhs) {
3341 auto result = basic_string(lhs);
3342 result += std::move(rhs);
3350 friend basic_string operator +(
const basic_string & lhs,
const char rhs) {
3359 friend basic_string operator +(
const basic_string & lhs,
const xtd::char16 rhs) {
3368 friend basic_string operator +(
const basic_string & lhs,
const xtd::char32 rhs) {
3377 friend basic_string operator +(
const basic_string & lhs,
const xtd::char8 rhs) {
3386 friend basic_string operator +(
const basic_string & lhs,
const xtd::wchar rhs) {
3396 friend basic_string operator +(basic_string&& lhs,
const char rhs) {
3397 auto result = std::move(lhs);
3405 friend basic_string operator +(basic_string&& lhs,
const xtd::char16 rhs) {
3406 auto result = std::move(lhs);
3414 friend basic_string operator +(basic_string&& lhs,
const xtd::char32 rhs) {
3415 auto result = std::move(lhs);
3423 friend basic_string operator +(basic_string&& lhs,
const xtd::char8 rhs) {
3424 auto result = std::move(lhs);
3432 friend basic_string operator +(basic_string&& lhs,
const xtd::wchar rhs) {
3433 auto result = std::move(lhs);
3442 friend basic_string operator +(
char lhs,
const basic_string & rhs) {
3443 auto result = basic_string(1, lhs);
3451 friend basic_string operator +(
xtd::char16 lhs,
const basic_string & rhs) {
3452 auto result = basic_string(1, lhs);
3460 friend basic_string operator +(
xtd::char32 lhs,
const basic_string & rhs) {
3461 auto result = basic_string(1, lhs);
3469 friend basic_string operator +(
xtd::char8 lhs,
const basic_string & rhs) {
3470 auto result = basic_string(1, lhs);
3478 friend basic_string operator +(
xtd::wchar lhs,
const basic_string & rhs) {
3479 auto result = basic_string(1, lhs);
3488 friend basic_string operator +(
char lhs, basic_string&& rhs) {
3489 auto result = basic_string(1, lhs);
3490 result += std::move(rhs);
3497 friend basic_string operator +(
xtd::char16 lhs, basic_string&& rhs) {
3498 auto result = basic_string(1, lhs);
3499 result += std::move(rhs);
3506 friend basic_string operator +(
xtd::char32 lhs, basic_string&& rhs) {
3507 auto result = basic_string(1, lhs);
3508 result += std::move(rhs);
3515 friend basic_string operator +(
xtd::char8 lhs, basic_string&& rhs) {
3516 auto result = basic_string(1, lhs);
3517 result += std::move(rhs);
3524 friend basic_string operator +(
xtd::wchar lhs, basic_string&& rhs) {
3525 auto result = basic_string(1, lhs);
3526 result += std::move(rhs);
3539 friend std::basic_ostream<char>& operator <<(std::basic_ostream<char>& stream,
const basic_string & str) {
3540 if constexpr(std::is_same_v<char, char_t>)
return stream << str.chars();
3541 else return stream << __xtd_convert_to_string<char>(str.chars());
3549 friend std::basic_ostream<xtd::wchar>& operator <<(std::basic_ostream<xtd::wchar>& stream,
const basic_string & str) {
return stream << str.to_wstring().chars();}
3559 friend std::basic_istream<char>& operator >>(std::basic_istream<char>& stream, basic_string & str) {
3560 auto s = std::basic_string<char> {};
3573 friend std::basic_istream<xtd::wchar>& operator >>(std::basic_istream<xtd::wchar>& stream, basic_string & str) {
3574 auto s = std::basic_string<xtd::wchar> {};
3582 friend class basic_string<char>;
3583 friend class basic_string<xtd::
char16>;
3584 friend class basic_string<xtd::char32>;
3585 friend class basic_string<xtd::char8>;
3586 friend class basic_string<xtd::wchar>;
3588 static const xtd::array<value_type> default_split_separators;
3589 static const xtd::array<value_type> default_trim_chars;
3591 template<class arg_t>
3592 static auto convert_param(arg_t&& arg) noexcept {
3593 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();
3594 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();
3595 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();
3596 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();
3597 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();
3598 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();
3599 else return std::forward<arg_t>(arg);
3602 static basic_string get_class_name(
const basic_string & full_name) {
3603 auto length = full_name.last_index_of(
"<");
3605 if (full_name.last_index_of(
"::", 0,
length) == npos)
return full_name;
3606 return full_name.substring(full_name.last_index_of(
"::", 0,
length) + 2);
3609 typename base_type::iterator to_base_type_iterator(
iterator value)
const noexcept {
3610 if (value ==
begin())
return chars_.begin();
3611 if (value ==
end())
return chars_.end();
3612 return chars_.begin() + (value -
begin());
3615 iterator to_iterator(
typename base_type::iterator value)
const noexcept {
3616 if (value == chars_.begin())
return begin();
3617 if (value == chars_.end())
return end();
3618 return begin() + (value - chars_.begin());