basic_string.hpp

Go to the documentation of this file.

 
#pragma once
#define __XTD_CORE_INTERNAL__
#include "internal/__array_definition.hpp"
#include "internal/__format_information.hpp"
#include "internal/__sprintf.hpp"
#include "internal/__string_definitions.hpp"
#undef __XTD_CORE_INTERNAL__
#define __XTD_STD_INTERNAL__
#include "internal/__xtd_std_version.hpp"
#undef __XTD_STD_INTERNAL__
#include "collections/generic/ienumerable.hpp"
#include "hash_code.hpp"
#include "icomparable.hpp"
#include "iequatable.hpp"
#include "null.hpp"
#include "string_comparison.hpp"
#include "string_split_options.hpp"
#include "types.hpp"
#include "object.hpp"
#include "parse.hpp"
#include "to_string.hpp"
#include "types.hpp"
#include "unused.hpp"
#include <cctype>
#if defined(__xtd__cpp_lib_format)
#include <format>
#endif
#include <iomanip>
#include <ostream>
#include <sstream>
#include <string>
 
template<class ...args_t>
void __basic_string_extract_format_arg(xtd::basic_string<char>& fmt, xtd::array<__format_information<char>>& formats, args_t&&... args);
template<class target_t, class source_t>
std::basic_string<target_t> __xtd_convert_to_string(std::basic_string<source_t>&& str) noexcept;
template<class target_t, class source_t>
std::basic_string<target_t> __xtd_convert_to_string(const std::basic_string<source_t>& str) noexcept;
std::basic_string<char> __xtd_demangle(const std::basic_string<char>& value) noexcept;
std::basic_string<char> __xtd_get_class_name(const std::type_info& value) noexcept;
std::basic_string<char> __xtd_get_full_class_name(const std::type_info& value) noexcept;
 
namespace xtd {
  template<class char_t, class traits_t, class allocator_t>
  class basic_string : public object, public xtd::icomparable<basic_string<char_t, traits_t, allocator_t>>, public xtd::iequatable<basic_string<char_t, traits_t, allocator_t>>, public xtd::collections::generic::ienumerable<char_t> {
  public:
    
    using base_type = std::basic_string<char_t, traits_t, allocator_t>;
    using traits_type = typename base_type::traits_type;
    using value_type = typename base_type::value_type;
    using allocator_type = typename base_type::allocator_type;
    using size_type = typename base_type::size_type;
    using difference_type = typename base_type::difference_type;
    using reference = typename base_type::reference;
    using const_reference = typename base_type::const_reference;
    using pointer = typename base_type::pointer;
    using const_pointer = typename base_type::const_pointer;
    using iterator = typename xtd::collections::generic::ienumerable<char_t>::iterator;
    using const_iterator = typename xtd::collections::generic::ienumerable<char_t>::const_iterator;
    using reverse_iterator = typename base_type::reverse_iterator;
    using const_reverse_iterator = typename base_type::const_reverse_iterator;
    using enumerator_type = typename xtd::collections::generic::enumerator<value_type>;
 
    
    static const basic_string empty_string;
    
    inline static constexpr size_type npos = base_type::npos;
    
    
    basic_string() = default;
    explicit basic_string(const allocator_type& allocator) noexcept;
 
    basic_string(const basic_string<char>& str) noexcept {
      if constexpr (std::is_same_v<char, char_t>) chars_ = str.chars_;
      else chars_ = __xtd_convert_to_string<value_type>(str.chars_);
    }
 
    basic_string(const basic_string<xtd::char16>& str) noexcept {
      if constexpr (std::is_same_v<xtd::char16, char_t>) chars_ = str.chars_;
      else chars_ = __xtd_convert_to_string<value_type>(str.chars_);
    }
    basic_string(const basic_string<xtd::char32>& str) noexcept {
      if constexpr (std::is_same_v<xtd::char32, char_t>) chars_ = str.chars_;
      else chars_ = __xtd_convert_to_string<value_type>(str.chars_);
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string(const basic_string<xtd::char8>& str) noexcept {
      if constexpr (std::is_same_v<xtd::char8, char_t>) chars_ = str.chars_;
      else chars_ = __xtd_convert_to_string<value_type>(str.chars_);
    }
#endif
    basic_string(const basic_string<xtd::wchar>& str) noexcept {
      if constexpr (std::is_same_v<xtd::wchar, char_t>) chars_ = str.chars_;
      else chars_ = __xtd_convert_to_string<value_type>(str.chars_);
    }
 
    basic_string(const basic_string<char>& str, const allocator_type& allocator) noexcept {
      if constexpr (std::is_same_v<char, char_t>) chars_ = base_type(str.chars_, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(str.chars_), allocator);
    }
    basic_string(const basic_string<xtd::char16>& str, const allocator_type& allocator) noexcept {
      if constexpr (std::is_same_v<xtd::char16, char_t>) chars_ = base_type(str.chars_, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(str.chars_), allocator);
    }
    basic_string(const basic_string<xtd::char32>& str, const allocator_type& allocator) noexcept {
      if constexpr (std::is_same_v<xtd::char32, char_t>) chars_ = base_type(str.chars_, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(str.chars_), allocator);
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string(const basic_string<xtd::char8>& str, const allocator_type& allocator) noexcept {
      if constexpr (std::is_same_v<xtd::char8, char_t>) chars_ = base_type(str.chars_, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(str.chars_), allocator);
    }
#endif
    basic_string(const basic_string<xtd::wchar>& str, const allocator_type& allocator) noexcept {
      if constexpr (std::is_same_v<xtd::wchar, char_t>) chars_ = base_type(str.chars_, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(str.chars_), allocator);
    }
 
    basic_string(const basic_string<char>& str, xtd::size index) {
      if (index > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<char, char_t>) chars_ = base_type(str.chars_, index);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<char>(str.chars_, index)));
    }
    basic_string(const basic_string<xtd::char16>& str, xtd::size index) {
      if (index > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<xtd::char16, char_t>) chars_ = base_type(str.chars_, index);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str.chars_, index)));
    }
    basic_string(const basic_string<xtd::char32>& str, xtd::size index) {
      if (index > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<xtd::char32, char_t>) chars_ = base_type(str.chars_, index);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str.chars_, index)));
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string(const basic_string<xtd::char8>& str, xtd::size index) {
      if (index > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<xtd::char8, char_t>) chars_ = base_type(str.chars_, index);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str.chars_, index)));
    }
#endif
    basic_string(const basic_string<xtd::wchar>& str, xtd::size index) {
      if (index > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<xtd::wchar, char_t>) chars_ = base_type(str.chars_, index);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str.chars_, index)));
    }
 
    basic_string(const basic_string<char>& str, xtd::size index, const allocator_type& allocator) {
      if (index > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<char, char_t>) chars_ = base_type(str.chars_, index, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<char>(str.chars_, index)), allocator);
    }
    basic_string(const basic_string<xtd::char16>& str, xtd::size index, const allocator_type& allocator) {
      if (index > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<xtd::char16, char_t>) chars_ = base_type(str.chars_, index, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str.chars_, index)), allocator);
    }
    basic_string(const basic_string<xtd::char32>& str, xtd::size index, const allocator_type& allocator) {
      if (index > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<xtd::char32, char_t>) chars_ = base_type(str.chars_, index, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str.chars_, index)), allocator);
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string(const basic_string<xtd::char8>& str, xtd::size index, const allocator_type& allocator) {
      if (index > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<xtd::char8, char_t>) chars_ = base_type(str.chars_, index, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str.chars_, index)), allocator);
    }
#endif
    basic_string(const basic_string<xtd::wchar>& str, xtd::size index, const allocator_type& allocator) {
      if (index > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<xtd::wchar, char_t>) chars_ = base_type(str.chars_, index, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str.chars_, index)), allocator);
    }
 
    basic_string(const basic_string<char>& str, xtd::size index, xtd::size count) {
      if (index + count > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<char, char_t>) chars_ = base_type(str.chars_, index, count);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<char>(str.chars_, index, count)));
    }
    basic_string(const basic_string<xtd::char16>& str, xtd::size index, xtd::size count) {
      if (index + count > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<xtd::char16, char_t>) chars_ = base_type(str.chars_, index, count);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str.chars_, index, count)));
    }
    basic_string(const basic_string<xtd::char32>& str, xtd::size index, xtd::size count) {
      if (index + count > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<xtd::char32, char_t>) chars_ = base_type(str.chars_, index, count);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str.chars_, index, count)));
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string(const basic_string<xtd::char8>& str, xtd::size index, xtd::size count) {
      if (index + count > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<xtd::char8, char_t>) chars_ = base_type(str.chars_, index, count);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str.chars_, index, count)));
    }
#endif
    basic_string(const basic_string<xtd::wchar>& str, xtd::size index, xtd::size count) {
      if (index + count > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<xtd::wchar, char_t>) chars_ = base_type(str.chars_, index, count);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str.chars_, index, count)));
    }
 
    basic_string(const basic_string<char>& str, xtd::size index, xtd::size count, const allocator_type& allocator) {
      if (index + count > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<char, char_t>) chars_ = base_type(str.chars_, index, count, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<char>(str.chars_, index, count)), allocator);
    }
    basic_string(const basic_string<xtd::char16>& str, xtd::size index, xtd::size count, const allocator_type& allocator) {
      if (index + count > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<xtd::char16, char_t>) chars_ = base_type(str.chars_, index, count, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str.chars_, index, count)), allocator);
    }
    basic_string(const basic_string<xtd::char32>& str, xtd::size index, xtd::size count, const allocator_type& allocator) {
      if (index + count > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<xtd::char32, char_t>) chars_ = base_type(str.chars_, index, count, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str.chars_, index, count)), allocator);
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string(const basic_string<xtd::char8>& str, xtd::size index, xtd::size count, const allocator_type& allocator) {
      if (index + count > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<xtd::char8, char_t>) chars_ = base_type(str.chars_, index, count, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str.chars_, index, count)), allocator);
    }
#endif
    basic_string(const basic_string<xtd::wchar>& str, xtd::size index, xtd::size count, const allocator_type& allocator) {
      if (index + count > str.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if constexpr (std::is_same_v<xtd::wchar, char_t>) chars_ = base_type(str.chars_, index, count, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str.chars_, index, count)), allocator);
    }
    
    basic_string(basic_string&&) = default;
 
    basic_string(basic_string&& str, const allocator_type& allocator) noexcept : chars_(std::move(str.chars_)) {}
 
    basic_string(xtd::size count, char character) : basic_string(std::basic_string<char>(count, character)) {}
    basic_string(xtd::size count, char character, const allocator_type& allocator) : basic_string(std::basic_string<char>(count, character), allocator) {}
    basic_string(xtd::size count, xtd::char16 character) : basic_string(std::basic_string<xtd::char16>(count, character)) {}
    basic_string(xtd::size count, xtd::char16 character, const allocator_type& allocator) : basic_string(std::basic_string<xtd::char16>(count, character), allocator) {}
    basic_string(xtd::size count, xtd::char32 character) : basic_string(std::basic_string<xtd::char32>(count, character)) {}
    basic_string(xtd::size count, xtd::char32 character, const allocator_type& allocator) : basic_string(std::basic_string<xtd::char32>(count, character), allocator) {}
#if defined(__xtd__cpp_lib_char8_t)
    basic_string(xtd::size count, xtd::char8 character) : basic_string(std::basic_string<xtd::char8>(count, character)) {}
    basic_string(xtd::size count, xtd::char8 character, const allocator_type& allocator) : basic_string(std::basic_string<xtd::char8>(count, character), allocator) {}
#endif
    basic_string(xtd::size count, xtd::wchar character) : basic_string(std::basic_string<xtd::wchar>(count, character)) {}
    basic_string(xtd::size count, xtd::wchar character, const allocator_type& allocator) : basic_string(std::basic_string<xtd::wchar>(count, character), allocator) {}
 
    basic_string(char character, xtd::size count) : basic_string(std::basic_string<char>(count, character)) {}
    basic_string(char character, xtd::size count, const allocator_type& allocator) : basic_string(std::basic_string<char>(count, character), allocator) {}
    basic_string(xtd::char16 character, xtd::size count) : basic_string(std::basic_string<xtd::char16>(count, character)) {}
    basic_string(xtd::char16 character, xtd::size count, const allocator_type& allocator) : basic_string(std::basic_string<xtd::char16>(count, character), allocator) {}
    basic_string(xtd::char32 character, xtd::size count) : basic_string(std::basic_string<xtd::char32>(count, character)) {}
    basic_string(xtd::char32 character, xtd::size count, const allocator_type& allocator) : basic_string(std::basic_string<xtd::char32>(count, character), allocator) {}
#if defined(__xtd__cpp_lib_char8_t)
    basic_string(xtd::char8 character, xtd::size count) : basic_string(std::basic_string<xtd::char8>(count, character)) {}
    basic_string(xtd::char8 character, xtd::size count, const allocator_type& allocator) : basic_string(std::basic_string<xtd::char8>(count, character), allocator) {}
#endif
    basic_string(xtd::wchar character, xtd::size count) : basic_string(std::basic_string<xtd::wchar>(count, character)) {}
    basic_string(xtd::wchar character, xtd::size count, const allocator_type& allocator) : basic_string(std::basic_string<xtd::wchar>(count, character), allocator) {}
 
    basic_string(const char* str) {  // Can't be explicit by design.
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<char, char_t>) chars_ = std::basic_string<char>(str);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<char>(str));
    }
    basic_string(const xtd::char16* str) {  // Can't be explicit by design.
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::char16, char_t>) chars_ = std::basic_string<xtd::char16>(str);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str));
    }
    basic_string(const xtd::char32* str) {  // Can't be explicit by design.
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::char32, char_t>) chars_ = std::basic_string<xtd::char32>(str);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str));
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string(const xtd::char8* str) {  // Can't be explicit by design.
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::char8, char_t>) chars_ = std::basic_string<xtd::char8>(str);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str));
    }
#endif
    basic_string(const xtd::wchar* str) {  // Can't be explicit by design.
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::wchar, char_t>) chars_ = std::basic_string<xtd::wchar>(str);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str));
    }
 
    basic_string(const char* str, const allocator_type& allocator) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<char, char_t>) chars_ = std::basic_string<char>(str, allocator);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<char>(str), allocator);
    }
    basic_string(const xtd::char16* str, const allocator_type& allocator) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::char16, char_t>) chars_ = std::basic_string<xtd::char16>(str, allocator);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str), allocator);
    }
    basic_string(const xtd::char32* str, const allocator_type& allocator) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::char32, char_t>) chars_ = std::basic_string<xtd::char32>(str, allocator);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str), allocator);
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string(const xtd::char8* str, const allocator_type& allocator) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::char8, char_t>) chars_ = std::basic_string<xtd::char8>(str, allocator);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str), allocator);
    }
#endif
    basic_string(const xtd::wchar* str, const allocator_type& allocator) : chars_(allocator) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::wchar, char_t>) chars_ = std::basic_string<xtd::wchar>(str);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str));
    }
 
    basic_string(const char* str, xtd::size count) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<char, char_t>) chars_ = std::basic_string<char>(str, count);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<char>(str, count));
    }
    basic_string(const xtd::char16* str, xtd::size count) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::char16, char_t>) chars_ = std::basic_string<xtd::char16>(str, count);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str, count));
    }
    basic_string(const xtd::char32* str, xtd::size count) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::char32, char_t>) chars_ = std::basic_string<xtd::char32>(str, count);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str, count));
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string(const xtd::char8* str, xtd::size count) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::char8, char_t>) chars_ = std::basic_string<xtd::char8>(str, count);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str, count));
    }
#endif
    basic_string(const xtd::wchar* str, xtd::size count) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::wchar, char_t>) chars_ = std::basic_string<xtd::wchar>(str, count);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str, count));
    }
 
    basic_string(const char* str, xtd::size count, const allocator_type& allocator) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<char, char_t>) chars_ = std::basic_string<char>(str, count, allocator);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<char>(str, count), allocator);
    }
    basic_string(const xtd::char16* str, xtd::size count, const allocator_type& allocator) : chars_(allocator) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::char16, char_t>) chars_ = std::basic_string<xtd::char16>(str, count, allocator);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str, count), allocator);
    }
    basic_string(const xtd::char32* str, xtd::size count, const allocator_type& allocator) : chars_(allocator) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::char32, char_t>) chars_ = std::basic_string<xtd::char32>(str, count, allocator);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str, count), allocator);
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string(const xtd::char8* str, xtd::size count, const allocator_type& allocator) : chars_(allocator) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::char8, char_t>) chars_ = std::basic_string<xtd::char8>(str, count, allocator);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str, count), allocator);
    }
#endif
    basic_string(const xtd::wchar* str, xtd::size count, const allocator_type& allocator) : chars_(allocator) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::wchar, char_t>) chars_ = std::basic_string<xtd::wchar>(str, count, allocator);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str, count), allocator);
    }
 
    basic_string(const std::basic_string<char>& str) noexcept { // Can't be explicit by design.
      if constexpr (std::is_same_v<char, char_t>) chars_ = str;
      else chars_ = __xtd_convert_to_string<value_type>(str);
    }
    basic_string(const std::basic_string<xtd::char16>& str) noexcept { // Can't be explicit by design.
      if constexpr (std::is_same_v<xtd::char16, char_t>) chars_ = str;
      else chars_ = __xtd_convert_to_string<value_type>(str);
    }
    basic_string(const std::basic_string<xtd::char32>& str) noexcept { // Can't be explicit by design.
      if constexpr (std::is_same_v<xtd::char32, char_t>) chars_ = str;
      else chars_ = __xtd_convert_to_string<value_type>(str);
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string(const std::basic_string<xtd::char8>& str) noexcept { // Can't be explicit by design.
      if constexpr (std::is_same_v<xtd::char8, char_t>) chars_ = str;
      else chars_ = __xtd_convert_to_string<value_type>(str);
    }
#endif
    basic_string(const std::basic_string<xtd::wchar>& str) noexcept { // Can't be explicit by design.
      if constexpr (std::is_same_v<xtd::wchar, char_t>) chars_ = str;
      else chars_ = __xtd_convert_to_string<value_type>(str);
    }
 
    basic_string(const std::basic_string<char>& str, const allocator_type& allocator) noexcept {
      if constexpr (std::is_same_v<char, char_t>) chars_ = base_type(str, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(str), allocator);
    }
    basic_string(const std::basic_string<xtd::char16>& str, const allocator_type& allocator) noexcept {
      if constexpr (std::is_same_v<xtd::char16, char_t>) chars_ = base_type(str, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(str), allocator);
    }
    basic_string(const std::basic_string<xtd::char32>& str, const allocator_type& allocator) noexcept {
      if constexpr (std::is_same_v<xtd::char32, char_t>) chars_ = base_type(str, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(str), allocator);
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string(const std::basic_string<xtd::char8>& str, const allocator_type& allocator) noexcept {
      if constexpr (std::is_same_v<xtd::char8, char_t>) chars_ = base_type(str, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(str), allocator);
    }
#endif
    basic_string(const std::basic_string<xtd::wchar>& str, const allocator_type& allocator) noexcept {
      if constexpr (std::is_same_v<xtd::wchar, char_t>) chars_ = base_type(str, allocator);
      else chars_ = base_type(__xtd_convert_to_string<value_type>(str), allocator);
    }
 
    template<class input_iterator_t>
    basic_string(input_iterator_t first, input_iterator_t last) : chars_(first, last) {}
    template<class input_iterator_t>
    basic_string(input_iterator_t first, input_iterator_t last, const allocator_type& allocator) : chars_(first, last, allocator) {}
 
    template<class string_view_like_t>
    explicit constexpr basic_string(const string_view_like_t& string_view) : chars_(string_view) {}
    template<class string_view_like_t>
    explicit constexpr basic_string(const string_view_like_t& string_view, const allocator_type& allocator) : chars_(string_view, allocator) {}
    template<class string_view_like_t>
    constexpr basic_string(const string_view_like_t& string_view, size_type index, size_type count) : chars_(string_view, index, count) {}
    template<class string_view_like_t>
    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) {}
 
    basic_string(std::initializer_list<char> il) : basic_string(std::basic_string<char>(il)) {}
    basic_string(std::initializer_list<xtd::char16> il) : basic_string(std::basic_string<xtd::char16>(il)) {}
    basic_string(std::initializer_list<xtd::char32> il) : basic_string(std::basic_string<xtd::char32>(il)) {}
#if defined(__xtd__cpp_lib_char8_t)
    basic_string(std::initializer_list<xtd::char8> il) : basic_string(std::basic_string<xtd::char8>(il)) {}
#endif
    basic_string(std::initializer_list<xtd::wchar> il) : basic_string(std::basic_string<xtd::wchar>(il)) {}
 
    basic_string(std::initializer_list<char> il, const allocator_type& allocator) : basic_string(std::basic_string<char>(il), allocator) {}
    basic_string(std::initializer_list<xtd::char16> il, const allocator_type& allocator) : basic_string(std::basic_string<xtd::char16>(il), allocator) {}
    basic_string(std::initializer_list<xtd::char32> il, const allocator_type& allocator) : basic_string(std::basic_string<xtd::char32>(il), allocator) {}
#if defined(__xtd__cpp_lib_char8_t)
    basic_string(std::initializer_list<xtd::char8> il, const allocator_type& allocator) : basic_string(std::basic_string<xtd::char8>(il), allocator) {}
#endif
    basic_string(std::initializer_list<xtd::wchar> il, const allocator_type& allocator) : basic_string(std::basic_string<xtd::wchar>(il), allocator) {}
    
    
    const_reference back() const {return operator[](size() - 1);}
    
    const_iterator begin() const override {return xtd::collections::generic::ienumerable<value_type>::begin();}
    
    const_pointer c_str() const noexcept {return chars_.c_str();}
    
    size_type capacity() const noexcept {return chars_.capacity();}
    
    const_iterator cbegin() const override {return xtd::collections::generic::ienumerable<value_type>::cbegin();}
    
    const_reverse_iterator crbegin() const {return chars_.crbegin();}
    
    const base_type& chars() const noexcept {return chars_;}
 
    const_iterator cend() const override {return xtd::collections::generic::ienumerable<value_type>::cend();}
 
    const_reverse_iterator crend() const {return chars_.crend();}
 
    const_pointer data() const noexcept {return chars_.data();}
    
    bool empty() const noexcept {return chars_.empty();}
    
    const_iterator end() const override {return xtd::collections::generic::ienumerable<value_type>::end();}
    
    const_reference front() const {return operator[](0);}
 
    size_type length() const noexcept {return chars_.size();}
    
    size_type max_size() const noexcept {return chars_.max_size();}
    
    const_reverse_iterator rbegin() const {return chars_.crbegin();}
 
    const_reverse_iterator rend() const {return chars_.crend();}
 
    size_type size() const noexcept {return chars_.size();}
 
    
    const_reference at(size_type pos) const {return operator [](pos);}
 
    int32 compare(const basic_string& str) const {return chars_.compare(str);}
    int32 compare(size_type pos1, size_type count1, const basic_string& str) const {return chars_.compare(pos1, count1, str);}
    int32 compare(size_type pos1, size_type count1, const basic_string& str, size_type pos2) const {return chars_.compare(pos1, count1, str, pos2);}
    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);}
    int32 compare(const_pointer s) const {return chars_.compare(s);}
    int32 compare(size_type pos1, size_type count1, const_pointer s) const {return chars_.compare(pos1, count1, s);}
    int32 compare(size_type pos1, size_type count1, const_pointer s, size_type count2) const {return chars_.compare(pos1, count1, s, count2);}
 
    int32 compare_to(const object& value) const {
      if (!dynamic_cast<const basic_string*>(&value)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
      return compare_to(static_cast<const basic_string&>(value));
    }
    int32 compare_to(const basic_string& value) const noexcept override {return chars_.compare(value.chars_);}
 
    virtual bool contains(value_type value) const noexcept {return find(value) != npos;}
    virtual bool contains(const basic_string& value) const noexcept {return find(value) != npos;}
 
    bool equals(const object& obj) const noexcept override {return dynamic_cast<const basic_string*>(&obj) && equals(static_cast<const basic_string&>(obj));}
    bool equals(const basic_string& value) const noexcept override {return equals(value, false);}
    bool equals(const basic_string& value, bool ignore_case) const noexcept {
      if (ignore_case) return to_upper().chars_ == value.to_upper().chars_;
      return chars_ == value.chars_;
    }
 
    bool ends_with(value_type value) const noexcept {return ends_with(value, false);}
    bool ends_with(value_type value, bool ignore_case) const noexcept {
      if (ignore_case) return to_lower().rfind(static_cast<value_type>(tolower(value))) == size() - 1;
      return rfind(value) == size() - 1;
    }
    bool ends_with(const basic_string& value) const noexcept {return ends_with(value, xtd::string_comparison::ordinal);}
    bool ends_with(const basic_string& value, bool ignore_case) const noexcept {return ends_with(value, ignore_case ? xtd::string_comparison::ordinal_ignore_case : xtd::string_comparison::ordinal);}
    bool ends_with(const basic_string& value, xtd::string_comparison comparison_type) const noexcept {
      if (comparison_type == xtd::string_comparison::ordinal_ignore_case) return to_lower().rfind(value.to_lower()) + value.to_lower().size() == size();
      return rfind(value) + value.size() == size();
    }
 
    size_type find(const basic_string& str) const {return chars_.find(str);}
    size_type find(const basic_string& str, size_type pos) const {return chars_.find(str, pos);}
    size_type find(const_pointer s, size_type pos, size_type count) const {return chars_.find(s, pos, count);}
    size_type find(const_pointer s) const {return chars_.find(s);}
    size_type find(const_pointer s, size_type pos) const {return chars_.find(s, pos);}
    size_type find(value_type ch) const {return chars_.find(ch);}
    size_type find(value_type ch, size_type pos) const {return chars_.find(ch, pos);}
 
    size_type find_first_of(const basic_string& str) const {return chars_.find_first_of(str);}
    size_type find_first_of(const basic_string& str, size_type pos) const {return chars_.find_first_of(str, pos);}
    size_type find_first_of(const_pointer s, size_type pos, size_type count) const {return chars_.find_first_of(s, pos, count);}
    size_type find_first_of(const_pointer s) const {return chars_.find_first_of(s);}
    size_type find_first_of(const_pointer s, size_type pos) const {return chars_.find_first_of(s, pos);}
    size_type find_first_of(char_t ch) const {return chars_.find_first_of(ch);}
    size_type find_first_of(char_t ch, size_type pos) const {return chars_.find_first_of(ch, pos);}
 
    size_type find_first_not_of(const basic_string& str) const {return chars_.find_first_not_of(str);}
    size_type find_first_not_of(const basic_string& str, size_type pos) const {return chars_.find_first_not_of(str, pos);}
    size_type find_first_not_of(const_pointer s, size_type pos, size_type count) const {return chars_.find_first_not_of(s, pos, count);}
    size_type find_first_not_of(const_pointer s) const {return chars_.find_first_not_of(s);}
    size_type find_first_not_of(const_pointer s, size_type pos) const {return chars_.find_first_not_of(s, pos);}
    size_type find_first_not_of(char_t ch) const {return chars_.find_first_not_of(ch);}
    size_type find_first_not_of(char_t ch, size_type pos) const {return chars_.find_first_not_of(ch, pos);}
 
    size_type find_last_of(const basic_string& str) const {return chars_.find_last_of(str);}
    size_type find_last_of(const basic_string& str, size_type pos) const {return chars_.find_last_of(str, pos);}
    size_type find_last_of(const_pointer s, size_type pos, size_type count) const {return chars_.find_last_of(s, pos, count);}
    size_type find_last_of(const_pointer s) const {return chars_.find_last_of(s);}
    size_type find_last_of(const_pointer s, size_type pos) const {return chars_.find_last_of(s, pos);}
    size_type find_last_of(char_t ch) const {return chars_.find_last_of(ch);}
    size_type find_last_of(char_t ch, size_type pos) const {return chars_.find_last_of(ch, pos);}
    
    size_type find_last_not_of(const basic_string& str) const {return chars_.find_last_not_of(str);}
    size_type find_last_not_of(const basic_string& str, size_type pos) const {return chars_.find_last_not_of(str, pos);}
    size_type find_last_not_of(const_pointer s, size_type pos, size_type count) const {return chars_.find_last_not_of(s, pos, count);}
    size_type find_last_not_of(const_pointer s) const {return chars_.find_last_not_of(s);}
    size_type find_last_not_of(const_pointer s, size_type pos) const {return chars_.find_last_not_of(s, pos);}
    size_type find_last_not_of(char_t ch) const {return chars_.find_last_not_of(ch);}
    size_type find_last_not_of(char_t ch, size_type pos) const {return chars_.find_last_not_of(ch, pos);}
    
    allocator_type get_allocator() const {return chars_.get_allocator();}
    
    virtual const base_type& get_base_type() const noexcept {return chars_;}
    
    xtd::size get_hash_code() const noexcept override {return xtd::hash_code::combine(chars_);}
    
    enumerator_type get_enumerator() const noexcept override {
      class basic_string_enumerator : public xtd::collections::generic::ienumerator<value_type> {
      public:
        explicit basic_string_enumerator(const basic_string& chars) : chars_(chars) {}
        
        const value_type& current() const override {return chars_[index_];}
        
        bool move_next() override {return ++index_ < chars_.size();}
        
        void reset() override {index_ = basic_string::npos;}
        
      protected:
        const basic_string& chars_;
        xtd::size index_ = basic_string::npos;
      };
      return {new_ptr<basic_string_enumerator>(*this)};
    }
 
    xtd::size index_of(const basic_string& value) const noexcept {return index_of(value, 0, size());}
    xtd::size index_of(const basic_string& value, xtd::size start_index) const {return index_of(value, start_index, size() - start_index);}
    xtd::size index_of(const basic_string& value, xtd::size start_index, xtd::size count) const {
      if (start_index > size() || start_index + count > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      auto result = find(value, start_index);
      return result > start_index + count ? npos : result;
    }
    xtd::size index_of(value_type value) const noexcept {return index_of(value, 0, size());}
    xtd::size index_of(value_type value, xtd::size start_index) const {return index_of(value, start_index, size() - start_index);}
    xtd::size index_of(value_type value, xtd::size start_index, xtd::size count) const {
      if (start_index > size() || start_index + count > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      auto result = find(value, start_index);
      return result > start_index + count ? npos : result;
    }
    
    xtd::size index_of_any(const xtd::array<value_type>& values) const noexcept;
    xtd::size index_of_any(const xtd::array<value_type>& values, xtd::size start_index) const;
    xtd::size index_of_any(const xtd::array<value_type>& values, xtd::size start_index, xtd::size count) const;
    xtd::size index_of_any(const std::initializer_list<value_type>& values) const noexcept;
    xtd::size index_of_any(const std::initializer_list<value_type>& values, xtd::size start_index) const;
    xtd::size index_of_any(const std::initializer_list<value_type>& values, xtd::size start_index, xtd::size count) const;
    
    basic_string insert(xtd::size start_index, const basic_string& value) const {
      if (start_index > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      auto result = *this;
      result.chars_.insert(start_index, value);
      return result;
    }
 
    [[deprecated("Replaced by xtd::basic_string::is_empty(const xtd::basic_string&) - Will be removed in version 0.4.0.")]]
    bool is_empty() const noexcept {return is_empty(*this);}
    
    xtd::size last_index_of(const basic_string& value) const noexcept {return last_index_of(value, 0, size());}
    xtd::size last_index_of(const basic_string& value, xtd::size start_index) const {return last_index_of(value, start_index, size() - start_index);}
    xtd::size last_index_of(const basic_string& value, xtd::size start_index, xtd::size count) const {
      if (start_index > size() || start_index + count > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      auto result = rfind(value, start_index + count - value.size());
      return result < start_index ? npos : result;
    }
    xtd::size last_index_of(value_type value) const noexcept {return last_index_of(value, 0, size());}
    xtd::size last_index_of(value_type value, xtd::size start_index) const {return last_index_of(value, start_index, size() - start_index);}
    xtd::size last_index_of(value_type value, xtd::size start_index, xtd::size count) const {
      if (start_index > size() || start_index + count > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      auto result = rfind(value, start_index + count - 1);
      return result < start_index ? npos : result;
    }
 
    xtd::size last_index_of_any(const xtd::array<value_type>& values) const noexcept;
    xtd::size last_index_of_any(const xtd::array<value_type>& values, xtd::size start_index) const;
    xtd::size last_index_of_any(const xtd::array<value_type>& values, xtd::size start_index, xtd::size count) const;
    xtd::size last_index_of_any(const std::initializer_list<value_type>& values) const noexcept;
    xtd::size last_index_of_any(const std::initializer_list<value_type>& values, xtd::size start_index) const;
    xtd::size last_index_of_any(const std::initializer_list<value_type>& values, xtd::size start_index, xtd::size count) const;
 
    basic_string pad_left(xtd::size total_width) const noexcept {return pad_left(total_width, ' ');}
    basic_string pad_left(xtd::size total_width, char32 padding_char) const noexcept {return total_width < size() ? *this : basic_string(total_width - size(), padding_char) + *this;}
    
    basic_string pad_right(xtd::size total_width) const noexcept {return pad_right(total_width, ' ');}
    basic_string pad_right(xtd::size total_width, char32 padding_char) const noexcept {return total_width < size() ? *this : *this + basic_string(total_width - size(), padding_char);}
 
    basic_string quoted() const {return quoted('"', '\\');}
    basic_string quoted(value_type delimiter) const {return quoted(delimiter, '\\');}
    basic_string quoted(value_type delimiter, value_type escape) const {
      std::wstringstream ss;
      if constexpr (std::is_same_v<xtd::wchar, value_type>) ss << std::quoted(chars_, delimiter, escape);
      else ss << std::quoted(__xtd_convert_to_string<xtd::wchar>(chars_), static_cast<xtd::wchar>(delimiter), static_cast<xtd::wchar>(escape));
      return ss.str();
    }
    
    basic_string remove(xtd::size start_index) const {return remove(start_index, size() - start_index);}
    basic_string remove(xtd::size start_index, xtd::size count) const {
      if (start_index > size() || start_index + count > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      auto result = *this;
      result.chars_.erase(start_index, count);
      return result;
    }
    
    basic_string replace(value_type old_char, value_type new_char) const noexcept {return replace(string(1, old_char), string(1, new_char));}
    basic_string replace(const basic_string& old_string, const basic_string& new_string) const noexcept {
      auto result = *this;
      auto old_size = old_string.size();
      auto new_size = new_string.size();
      auto index = xtd::size {0};
      while (true) {
        index = result.find(old_string, index);
        if (index == npos) break;
        if (old_size == new_size) result.chars_.replace(index, old_size, new_string);
        else {
          result.chars_.erase(index, old_string.size());
          result.chars_.insert(index, new_string);
        }
        index += new_string.size();
      }
      return result;
    }
 
    size_type rfind(const basic_string& str) const {return chars_.rfind(str);}
    size_type rfind(const basic_string& str, size_type pos) const {return chars_.rfind(str, pos);}
    size_type rfind(const_pointer s, size_type pos, size_type count) const {return chars_.rfind(s, pos, count);}
    size_type rfind(const_pointer s) const {return chars_.rfind(s);}
    size_type rfind(const_pointer s, size_type pos) const {return chars_.rfind(s, pos);}
    size_type rfind(value_type ch) const {return chars_.rfind(ch);}
    size_type rfind(value_type ch, size_type pos) const {return chars_.rfind(ch, pos);}
    
    xtd::array<basic_string> split() const noexcept;
    xtd::array<basic_string> split(value_type separator) const noexcept;
    xtd::array<basic_string> split(value_type separator, xtd::string_split_options options) const noexcept;
    xtd::array<basic_string> split(value_type separator, xtd::size count) const noexcept;
    xtd::array<basic_string> split(value_type separator, xtd::size count, xtd::string_split_options options) const noexcept;
    xtd::array<basic_string> split(const xtd::array<value_type>& separators) const noexcept;
    xtd::array<basic_string> split(const xtd::array<value_type>& separators, xtd::string_split_options options) const noexcept;
    xtd::array<basic_string> split(const xtd::array<value_type>& separators, xtd::size count) const noexcept;
    xtd::array<basic_string> split(const xtd::array<value_type>& separators, xtd::size count, xtd::string_split_options options) const noexcept;
    
    bool starts_with(value_type value) const noexcept {return starts_with(value, false);}
    bool starts_with(value_type value, bool ignore_case) const noexcept {
      if (ignore_case) return to_lower().find(static_cast<value_type>(tolower(value))) == 0;
      return find(value) == 0;
    }
    bool starts_with(const basic_string& value) const noexcept {return starts_with(value, string_comparison::ordinal);}
    bool starts_with(const basic_string& value, bool ignore_case) const noexcept {return starts_with(value, ignore_case ? string_comparison::ordinal_ignore_case : string_comparison::ordinal);}
    bool starts_with(const basic_string& value, xtd::string_comparison comparison_type) const noexcept {
      if (comparison_type == xtd::string_comparison::ordinal_ignore_case) return to_lower().find(value.to_lower()) == 0;
      return find(value) == 0;
    }
 
    basic_string substr() const {return chars_.substr();}
    basic_string substr(size_type pos) const {
      if (pos > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return chars_.substr(pos);
    }
    basic_string substr(size_type pos, size_type count) const {
      if (pos > size() || pos + count > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return chars_.substr(pos, count);
    }
  
    basic_string substring(xtd::size start_index) const {
      if (start_index > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return substr(start_index);
    }
    basic_string substring(xtd::size start_index, xtd::size length) const {
      if (start_index > size() || start_index + length > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return substr(start_index, length);
    }
    
    xtd::array<value_type> to_array() const noexcept;
    xtd::array<value_type> to_array(xtd::size start_index) const;
    xtd::array<value_type> to_array(xtd::size start_index, xtd::size length) const;
    
    xtd::array<value_type> to_char_array() const noexcept;
    xtd::array<value_type> to_char_array(xtd::size start_index, xtd::size length) const;
    
    basic_string to_lower() const noexcept {
      auto result = basic_string::empty_string;
      std::for_each(chars_.begin(), chars_.end(), [&](auto c) {result += static_cast<value_type>(std::tolower(c));});
      return result;
    }
 
    basic_string<char> to_string() const noexcept override {
      if constexpr (std::is_same_v<char, char_t>) return chars_;
      else return __xtd_convert_to_string<char>(chars_);
    }
    
    basic_string to_title_case() const noexcept;
 
    basic_string<xtd::char16> to_u16string() const noexcept {
      if constexpr (std::is_same_v<xtd::char16, char_t>) return chars_;
      else return __xtd_convert_to_string<xtd::char16>(chars_);
    }
    
    basic_string<xtd::char32> to_u32string() const noexcept {
      if constexpr (std::is_same_v<xtd::char32, char_t>) return chars_;
      else return __xtd_convert_to_string<xtd::char32>(chars_);
    }
    
#if defined(__xtd__cpp_lib_char8_t)
    basic_string<xtd::char8> to_u8string() const noexcept {
      if constexpr (std::is_same_v<xtd::char8, char_t>) return chars_;
      else return __xtd_convert_to_string<xtd::char8>(chars_);
    }
#endif
    
    basic_string to_upper() const noexcept {
      auto result = basic_string::empty_string;
      std::for_each(chars_.begin(), chars_.end(), [&](auto c) {result += static_cast<value_type>(std::toupper(c));});
      return result;
    }
 
    basic_string<xtd::wchar> to_wstring() const noexcept {
      if constexpr (std::is_same_v<xtd::wchar, char_t>) return chars_;
      else return __xtd_convert_to_string<xtd::wchar>(chars_);
    }
    
    basic_string trim() const noexcept {return trim(default_trim_chars);}
    basic_string trim(value_type trim_char) const noexcept;
    basic_string trim(const xtd::array<value_type>& trim_chars) const noexcept;
    
    basic_string trim_end() const noexcept {return trim_end(default_trim_chars);}
    basic_string trim_end(value_type trim_char) const noexcept;
    basic_string trim_end(const xtd::array<value_type>& trim_chars) const noexcept;
    
    basic_string trim_start() const noexcept {return trim_start(default_trim_chars);}
    basic_string trim_start(value_type trim_char) const noexcept;
    basic_string trim_start(const xtd::array<value_type>& trim_chars) const noexcept;
    
    
    template<class object_t>
    [[deprecated("Replaced by typeof_<object_t>().name() - Will be removed in version 0.4.0.")]]
    static basic_string class_name() {return get_class_name(full_class_name<object_t>());}
    template<class object_t>
    [[deprecated("Replaced by typeof_(object).name() - Will be removed in version 0.4.0.")]]
    static basic_string class_name(const object_t& object) {return get_class_name(full_class_name(object));}
    [[deprecated("Replaced by typeof_(info).name() - Will be removed in version 0.4.0.")]]
    static basic_string class_name(const std::type_info& info) {return __xtd_get_class_name(info);}
    
    static int32 compare(const basic_string& str_a, const basic_string& str_b) noexcept {return compare(str_a, str_b, false);}
    static int32 compare(const basic_string& str_a, const basic_string& str_b, bool ignore_case) noexcept {return compare(str_a, str_b, ignore_case ? xtd::string_comparison::ordinal_ignore_case : xtd::string_comparison::ordinal);}
    static int32 compare(const basic_string& str_a, const basic_string& str_b, xtd::string_comparison comparison_type) noexcept {return comparison_type == xtd::string_comparison::ordinal_ignore_case ? str_a.to_lower().compare(str_b.to_lower()) : str_a.compare(str_b);}
    static int32 compare(const basic_string& str_a, xtd::size index_a, const basic_string& str_b, xtd::size index_b, xtd::size length) {return compare(str_a, index_a, str_b, index_b, length, false);}
    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);}
    static int32 compare(const basic_string& str_a, xtd::size index_a, const basic_string& str_b, xtd::size index_b, xtd::size length, xtd::string_comparison comparison_type) {return comparison_type == xtd::string_comparison::ordinal_ignore_case ? str_a.substr(index_a, length).to_lower().compare(str_b.substr(index_b, length).to_lower()) : str_a.substr(index_a, length).compare(str_b.substr(index_b, length));}
 
    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;}
    template<class object_a_t, class object_b_t, class object_c_t, class object_d_t>
    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);}
    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;}
    template<class object_a_t, class object_b_t, class object_c_t>
    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);}
    static basic_string concat(const basic_string& str_a, const basic_string& str_b) noexcept {return str_a + str_b;}
    template<class object_a_t, class object_b_t>
    static basic_string concat(object_a_t obj_a, object_b_t obj_b) noexcept {return format("{}{}", obj_a, obj_b);}
    static basic_string concat(const xtd::array<basic_string>& values) noexcept;
    static basic_string concat(const xtd::array<const_pointer>& values) noexcept;
    template<class other_char_t>
    static basic_string concat(const xtd::array<const other_char_t*>& values) noexcept;
    static basic_string concat(const std::initializer_list<basic_string>& values) noexcept {
      auto result = basic_string::empty_string;
      std::for_each(values.begin(), values.end(), [&](const auto & item) {result += item;});
      return result;
    }
    static basic_string concat(const std::initializer_list<const_pointer>& values) noexcept {
      auto result = basic_string::empty_string;
      std::for_each(values.begin(), values.end(), [&](const auto & item) {result += item;});
      return result;
    }
    template<class other_char_t>
    static basic_string concat(const std::initializer_list<const other_char_t*>& values) noexcept {
      auto result = basic_string::empty_string;
      std::for_each(values.begin(), values.end(), [&](const auto & item) {result += item;});
      return result;
    }
    template<class object_t>
    static basic_string concat(const xtd::array<object_t>& args) noexcept;
    template<class object_t>
    static basic_string concat(const std::initializer_list<object_t>& args) noexcept {
      basic_string result;
      for (const auto& arg : args)
        result += format("{}", arg);
      return result;
    }
    template<class value_t>
    static basic_string concat(value_t value) noexcept {
      return format("{}", value);
    }
 
    static basic_string demangle(const basic_string& name) {
      if constexpr (std::is_same_v<char, char_t>) return __xtd_demangle(name.chars());
      else return __xtd_demangle(__xtd_convert_to_string<char>(name.chars()));
    }
 
    static bool equals(const basic_string& a, const basic_string& b) noexcept{return a.equals(b);}
    template<class char_a_t, class char_b_t>
    static bool equals(const char_a_t* a, const char_b_t* b) noexcept{return basic_string {a}.equals(basic_string {b});}
 
    static bool equals(const basic_string& a, const basic_string& b, bool ignore_case) noexcept {return a.equals(b, ignore_case);}
    template<class char_a_t, class char_b_t>
    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);}
 
    template<class ...args_t>
    static basic_string format(const basic_string<char>& fmt, args_t&& ... args);
 
    template<class object_t>
    [[deprecated("Replaced by typeof_<object_t>().full_name() - Will be removed in version 0.4.0.")]]
    static basic_string full_class_name() {return demangle(typeid(object_t).name());}
    template<class object_t>
    [[deprecated("Replaced by typeof_(object).full_name() - Will be removed in version 0.4.0.")]]
    static basic_string full_class_name(const object_t& object) {return demangle(typeid(object).name());}
    [[deprecated("Replaced by typeof_(info).full_name() - Will be removed in version 0.4.0.")]]
    static basic_string full_class_name(const std::type_info& info) {return __xtd_get_full_class_name(info);}
 
    static bool is_empty(const xtd::basic_string<value_type, traits_type, allocator_type>& string) noexcept {return !string.length();}
    
    template<class collection_t>
    static basic_string join(const basic_string separator, const collection_t& values) noexcept {
      xtd::size i = 0;
      basic_string result;
      for (const auto& item : values)
        result += format("{}{}", (i++ != 0 ? separator : basic_string {}), item);
      return result;
    }
    template<class collection_t>
    static basic_string join(const basic_string& separator, const collection_t& values, xtd::size index) {return join(separator, values, index, values.size() - index);}
    template<class collection_t>
    static basic_string join(const basic_string& separator, const collection_t& values, xtd::size index, xtd::size count) {
      if (index > values.size() || index + count > values.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      xtd::size i = 0;
      basic_string result;
      for (const auto& item : values) {
        if (i >= index) result += format("{}{}", (i != index ? separator : basic_string {}), item);
        if (++i >= index + count) break;
      }
      return result;
    }
 
    template<class value_t>
    static basic_string join(const basic_string& separator, const std::initializer_list<value_t>& values) noexcept;
    template<class value_t>
    static basic_string join(const basic_string& separator, const std::initializer_list<value_t>& values, xtd::size index);
    template<class value_t>
    static basic_string join(const basic_string& separator, const std::initializer_list<value_t>& values, xtd::size index, xtd::size count);
    
    template<class value_t>
    static value_t parse(const basic_string& str) {
      if constexpr (std::is_same_v<char, char_t>) return xtd::parse<value_t>(str.chars());
      else return xtd::parse<value_t>(__xtd_convert_to_string<char>(str.chars()));
    }
 
    template<class ...args_t>
    static basic_string sprintf(const basic_string& fmt, args_t&& ... args) noexcept {return __sprintf(fmt.c_str(), convert_param(std::forward<args_t>(args)) ...);}
    
    template<class value_t>
    static bool try_parse(const basic_string& str, value_t& value) noexcept {
      try {
        value = parse<value_t>(str);
        return true;
      } catch (...) {
        return false;
      }
    }
    
    
    const_reference operator [](xtd::size index) const {
      if (index >= length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      return chars_[index];
    }
    
    operator const base_type&() const noexcept {return chars_;}
 
    basic_string& operator =(const basic_string<char>& str) noexcept {
      if constexpr(std::is_same<char_t, char>::value) chars_ = str.chars_;
      else chars_ = __xtd_convert_to_string<value_type>(str.chars());
      return *this;
    }
    basic_string& operator =(const basic_string<xtd::char16>& str) noexcept {
      if constexpr(std::is_same<char_t, xtd::char16>::value) chars_ = str.chars_;
      else chars_ = __xtd_convert_to_string<value_type>(str.chars());
      return *this;
    }
    basic_string& operator =(const basic_string<xtd::char32>& str) noexcept {
      if constexpr(std::is_same<char_t, xtd::char32>::value) chars_ = str.chars_;
      else chars_ = __xtd_convert_to_string<value_type>(str.chars());
      return *this;
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string& operator =(const basic_string<xtd::char8>& str) noexcept {
      if constexpr(std::is_same<char_t, xtd::char8>::value) chars_ = str.chars_;
      else chars_ = __xtd_convert_to_string<value_type>(str.chars());
      return *this;
    }
#endif
    basic_string& operator =(const basic_string<xtd::wchar>& str) noexcept {
      if constexpr(std::is_same<char_t, xtd::wchar>::value) chars_ = str.chars_;
      else chars_ = __xtd_convert_to_string<value_type>(str.chars());
      return *this;
    }
 
    basic_string& operator =(basic_string<char>&& str) noexcept {
      if constexpr(std::is_same<char_t, char>::value) chars_ = std::move(str.chars_);
      else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str.chars_)));
      return *this;
    }
    basic_string& operator =(basic_string<xtd::char16>&& str) noexcept {
      if constexpr(std::is_same<char_t, xtd::char16>::value) chars_ = std::move(str.chars_);
      else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str.chars_)));
      return *this;
    }
    basic_string& operator =(basic_string<xtd::char32>&& str) noexcept {
      if constexpr(std::is_same<char_t, xtd::char32>::value) chars_ = std::move(str.chars_);
      else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str.chars_)));
      return *this;
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string& operator =(basic_string<xtd::char8>&& str) noexcept {
      if constexpr(std::is_same<char_t, xtd::char8>::value) chars_ = std::move(str.chars_);
      else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str.chars_)));
      return *this;
    }
#endif
    basic_string& operator =(basic_string<xtd::wchar>&& str) noexcept {
      if constexpr(std::is_same<char_t, xtd::wchar>::value) chars_ = std::move(str.chars_);
      else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str.chars_)));
      return *this;
    }
 
    basic_string& operator =(const std::basic_string<char>& str) noexcept {
      if constexpr(std::is_same<char_t, char>::value) chars_ = str;
      else chars_ = __xtd_convert_to_string<value_type>(str);
      return *this;
    }
    basic_string& operator =(const std::basic_string<xtd::char16>& str) noexcept {
      if constexpr(std::is_same<char_t, xtd::char16>::value) chars_ = str;
      else chars_ = __xtd_convert_to_string<value_type>(str);
      return *this;
    }
    basic_string& operator =(const std::basic_string<xtd::char32>& str) noexcept {
      if constexpr(std::is_same<char_t, xtd::char32>::value) chars_ = str;
      else chars_ = __xtd_convert_to_string<value_type>(str);
      return *this;
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string& operator =(const std::basic_string<xtd::char8>& str) noexcept {
      if constexpr(std::is_same<char_t, xtd::char8>::value) chars_ = str;
      else chars_ = __xtd_convert_to_string<value_type>(str);
      return *this;
    }
#endif
    basic_string& operator =(const std::basic_string<xtd::wchar>& str) noexcept {
      if constexpr(std::is_same<char_t, xtd::wchar>::value) chars_ = str;
      else chars_ = __xtd_convert_to_string<value_type>(str);
      return *this;
    }
 
    basic_string& operator =(std::basic_string<char>&& str) noexcept {
      if constexpr(std::is_same<char_t, char>::value) chars_ = std::move(str);
      else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str)));
      return *this;
    }
    basic_string& operator =(std::basic_string<xtd::char16>&& str) noexcept {
      if constexpr(std::is_same<char_t, xtd::char16>::value) chars_ = std::move(str);
      else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str)));
      return *this;
    }
    basic_string& operator =(std::basic_string<xtd::char32>&& str) noexcept {
      if constexpr(std::is_same<char_t, xtd::char32>::value) chars_ = std::move(str);
      else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str)));
      return *this;
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string& operator =(std::basic_string<xtd::char8>&& str) noexcept {
      if constexpr(std::is_same<char_t, xtd::char8>::value) chars_ = std::move(str);
      else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str)));
      return *this;
    }
#endif
    basic_string& operator =(std::basic_string<xtd::wchar>&& str) noexcept {
      if constexpr(std::is_same<char_t, xtd::wchar>::value) chars_ = std::move(str);
      else chars_ = std::move(__xtd_convert_to_string<value_type>(std::move(str)));
      return *this;
    }
 
    basic_string& operator =(const char* str) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<char, char_t>) chars_ = std::basic_string<char>(str);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<char>(str));
      return *this;
    }
    basic_string& operator =(const xtd::char16* str) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::char16, char_t>) chars_ = std::basic_string<xtd::char16>(str);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char16>(str));
      return *this;
    }
    basic_string& operator =(const xtd::char32* str) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::char32, char_t>) chars_ = std::basic_string<xtd::char32>(str);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char32>(str));
      return *this;
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string& operator =(const xtd::char8* str) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::char8, char_t>) chars_ = std::basic_string<xtd::char8>(str);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::char8>(str));
      return *this;
    }
#endif
    basic_string& operator =(const xtd::wchar* str) {
      if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      if constexpr (std::is_same_v<xtd::wchar, char_t>) chars_ = std::basic_string<xtd::wchar>(str);
      else chars_ = __xtd_convert_to_string<value_type>(std::basic_string<xtd::wchar>(str));
      return *this;
    }
 
    basic_string& operator =(char character) {
      *this = basic_string(1, character);
      return  *this;
    }
    basic_string& operator =(xtd::char16 character) {
      *this = basic_string(1, character);
      return  *this;
    }
    basic_string& operator =(xtd::char32 character) {
      *this = basic_string(1, character);
      return  *this;
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string& operator =(xtd::char8 character) {
      *this = basic_string(1, character);
      return  *this;
    }
#endif
    basic_string& operator =(xtd::wchar character) {
      *this = basic_string(1, character);
      return  *this;
    }
 
    basic_string& operator =(const std::initializer_list<char>& il) {
      *this = basic_string(il);
      return *this;
    }
    basic_string& operator =(const std::initializer_list<xtd::char16>& il) {
      *this = basic_string(il);
      return *this;
    }
    basic_string& operator =(const std::initializer_list<xtd::char32>& il) {
      *this = basic_string(il);
      return *this;
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string& operator =(const std::initializer_list<xtd::char8>& il) {
      *this = basic_string(il);
      return *this;
    }
#endif
    basic_string& operator =(const std::initializer_list<xtd::wchar>& il) {
      *this = basic_string(il);
      return *this;
    }
 
    basic_string& operator +=(const basic_string<char>& str) {
      if constexpr (std::is_same_v<char, char_t>) chars_ += str.chars_;
      else chars_ += __xtd_convert_to_string<value_type>(str.chars_);
      return *this;
    }
    basic_string& operator +=(const basic_string<xtd::char16>& str) {
      if constexpr (std::is_same_v<xtd::char16, char_t>) chars_ += str.chars_;
      else chars_ += __xtd_convert_to_string<value_type>(str.chars_);
      return *this;
    }
    basic_string& operator +=(const basic_string<xtd::char32>& str) {
      if constexpr (std::is_same_v<xtd::char32, char_t>) chars_ += str.chars_;
      else chars_ += __xtd_convert_to_string<value_type>(str.chars_);
      return *this;
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string& operator +=(const basic_string<xtd::char8>& str) {
      if constexpr (std::is_same_v<xtd::char8, char_t>) chars_ += str.chars_;
      else chars_ += __xtd_convert_to_string<value_type>(str.chars_);
      return *this;
    }
#endif
    basic_string& operator +=(const basic_string<xtd::wchar>& str) {
      if constexpr (std::is_same_v<xtd::wchar, char_t>) chars_ += str.chars_;
      else chars_ += __xtd_convert_to_string<value_type>(str.chars_);
      return *this;
    }
 
    basic_string& operator +=(basic_string<char>&& str) {
      if constexpr (std::is_same_v<char, char_t>) chars_ += std::move(str.chars_);
      else chars_ += __xtd_convert_to_string<value_type>(std::move(str.chars_));
      return *this;
    }
    basic_string& operator +=(basic_string<xtd::char16>&& str) {
      if constexpr (std::is_same_v<xtd::char16, char_t>) chars_ += std::move(str.chars_);
      else chars_ += __xtd_convert_to_string<value_type>(std::move(str.chars_));
      return *this;
    }
    basic_string& operator +=(basic_string<xtd::char32>&& str) {
      if constexpr (std::is_same_v<xtd::char32, char_t>) chars_ += std::move(str.chars_);
      else chars_ += __xtd_convert_to_string<value_type>(std::move(str.chars_));
      return *this;
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string& operator +=(basic_string<xtd::char8>&& str) {
      if constexpr (std::is_same_v<xtd::char8, char_t>) chars_ += std::move(str.chars_);
      else chars_ += __xtd_convert_to_string<value_type>(std::move(str.chars_));
      return *this;
    }
#endif
    basic_string& operator +=(basic_string<xtd::wchar>&& str) {
      if constexpr (std::is_same_v<xtd::wchar, char_t>) chars_ += std::move(str.chars_);
      else chars_ += __xtd_convert_to_string<value_type>(std::move(str.chars_));
      return *this;
    }
    
    basic_string& operator +=(const std::basic_string<char>& str) {
      if constexpr (std::is_same_v<char, char_t>) chars_ += str;
      else chars_ += __xtd_convert_to_string<value_type>(str);
      return *this;
    }
    basic_string& operator +=(const std::basic_string<xtd::char16>& str) {
      if constexpr (std::is_same_v<xtd::char16, char_t>) chars_ += str;
      else chars_ += __xtd_convert_to_string<value_type>(str);
      return *this;
    }
    basic_string& operator +=(const std::basic_string<xtd::char32>& str) {
      if constexpr (std::is_same_v<xtd::char32, char_t>) chars_ += str;
      else chars_ += __xtd_convert_to_string<value_type>(str);
      return *this;
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string& operator +=(const std::basic_string<xtd::char8>& str) {
      if constexpr (std::is_same_v<xtd::char8, char_t>) chars_ += str;
      else chars_ += __xtd_convert_to_string<value_type>(str);
      return *this;
    }
#endif
    basic_string& operator +=(const std::basic_string<xtd::wchar>& str) {
      if constexpr (std::is_same_v<xtd::wchar, char_t>) chars_ += str;
      else chars_ += __xtd_convert_to_string<value_type>(str);
      return *this;
    }
 
    basic_string& operator +=(const char* str) {
      chars_ += basic_string(str).chars_;
      return *this;
    }
    basic_string& operator +=(const xtd::char16* str) {
      chars_.append(basic_string(str).chars_); return *this;
    }
    basic_string& operator +=(const xtd::char32* str) {
      chars_ += basic_string(str).chars_;
      return *this;
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string& operator +=(const xtd::char8* str) {
      chars_ += basic_string(str).chars_;
      return *this;
    }
#endif
    basic_string& operator +=(const xtd::wchar* str) {
      chars_ += basic_string(str).chars_;
      return *this;
    }
    basic_string& operator +=(char ch) {
      chars_ += basic_string(1, ch).chars_;
      return *this;
    }
    basic_string& operator +=(xtd::char16 ch) {
      chars_ += basic_string(1, ch).chars_;
      return *this;
    }
    basic_string& operator +=(xtd::char32 ch) {
      chars_ += basic_string(1, ch).chars_;
      return *this;
    }
#if defined(__xtd__cpp_lib_char8_t)
    basic_string& operator +=(xtd::char8 ch) {
      chars_ += basic_string(1, ch).chars_;
      return *this;
    }
#endif
    basic_string& operator +=(xtd::wchar ch) {
      chars_ += basic_string(1, ch).chars_;
      return *this;
    }
 
    friend basic_string operator +(const basic_string& lhs, const basic_string<char>& rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
    friend basic_string operator +(const basic_string& lhs, const basic_string<xtd::char16>& rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
    friend basic_string operator +(const basic_string& lhs, const basic_string<xtd::char32>& rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
#if defined(__xtd__cpp_lib_char8_t)
    friend basic_string operator +(const basic_string& lhs, const basic_string<xtd::char8>& rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
#endif
    friend basic_string operator +(const basic_string& lhs, const basic_string<xtd::wchar>& rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
 
    friend basic_string operator +(basic_string&& lhs, basic_string<char>&& rhs) {
      auto result = std::move(lhs);
      result += std::move(rhs);
      return result;
    }
    friend basic_string operator +(basic_string&& lhs, basic_string<xtd::char16>&& rhs) {
      auto result = std::move(lhs);
      result += std::move(rhs);
      return result;
    }
    friend basic_string operator +(basic_string&& lhs, basic_string<xtd::char32>&& rhs) {
      auto result = std::move(lhs);
      result += std::move(rhs);
      return result;
    }
#if defined(__xtd__cpp_lib_char8_t)
    friend basic_string operator +(basic_string&& lhs, basic_string<xtd::char8>&& rhs) {
      auto result = std::move(lhs);
      result += std::move(rhs);
      return result;
    }
#endif
    friend basic_string operator +(basic_string&& lhs, basic_string<xtd::wchar>&& rhs) {
      auto result = std::move(lhs);
      result += std::move(rhs);
      return result;
    }
 
    friend basic_string operator +(basic_string&& lhs, const basic_string<char>& rhs) {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }
    friend basic_string operator +(basic_string&& lhs, const basic_string<xtd::char16>& rhs) {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }
    friend basic_string operator +(basic_string&& lhs, const basic_string<xtd::char32>& rhs) {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }
#if defined(__xtd__cpp_lib_char8_t)
    friend basic_string operator +(basic_string&& lhs, const basic_string<xtd::char8>& rhs) {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }
#endif
    friend basic_string operator +(basic_string&& lhs, const basic_string<xtd::wchar>& rhs) {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }
 
    friend basic_string operator +(const basic_string& lhs, basic_string<char>&& rhs) {
      auto result = lhs;
      result += std::move(rhs);
      return result;
    }
    friend basic_string operator +(const basic_string& lhs, basic_string<xtd::char16>&& rhs) {
      auto result = lhs;
      result += std::move(rhs);
      return result;
    }
    friend basic_string operator +(const basic_string& lhs, basic_string<xtd::char32>&& rhs) {
      auto result = lhs;
      result += std::move(rhs);
      return result;
    }
#if defined(__xtd__cpp_lib_char8_t)
    friend basic_string operator +(const basic_string& lhs, basic_string<xtd::char8>&& rhs) {
      auto result = lhs;
      result += std::move(rhs);
      return result;
    }
#endif
    friend basic_string operator +(const basic_string& lhs, basic_string<xtd::wchar>&& rhs) {
      auto result = lhs;
      result += std::move(rhs);
      return result;
    }
 
    friend basic_string operator +(const basic_string& lhs, const std::basic_string<char>& rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
    friend basic_string operator +(const basic_string& lhs, const std::basic_string<xtd::char16>& rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
    friend basic_string operator +(const basic_string& lhs, const std::basic_string<xtd::char32>& rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
#if defined(__xtd__cpp_lib_char8_t)
    friend basic_string operator +(const basic_string& lhs, const std::basic_string<xtd::char8>& rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
#endif
    friend basic_string operator +(const basic_string& lhs, const std::basic_string<xtd::wchar>& rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
 
    friend basic_string operator +(const std::basic_string<char>& lhs, const basic_string& rhs) {
      auto result = lhs;
      if constexpr (std::is_same_v<char, char_t>) result += rhs.chars();
      else result += __xtd_convert_to_string<char>(rhs.chars());
      return result;
    }
    friend basic_string operator +(const std::basic_string<xtd::char16>& lhs, const basic_string& rhs) {
      auto result = lhs;
      if constexpr (std::is_same_v<xtd::char16, char_t>) result += rhs.chars();
      else result += __xtd_convert_to_string<xtd::char16>(rhs.chars());
      return result;
    }
    friend basic_string operator +(const std::basic_string<xtd::char32>& lhs, const basic_string& rhs) {
      auto result = lhs;
      if constexpr (std::is_same_v<xtd::char32, char_t>) result += rhs.chars();
      else result += __xtd_convert_to_string<xtd::char32>(rhs.chars());
      return result;
    }
#if defined(__xtd__cpp_lib_char8_t)
    friend basic_string operator +(const std::basic_string<xtd::char8>& lhs, const basic_string& rhs) {
      auto result = lhs;
      if constexpr (std::is_same_v<xtd::char8, char_t>) result += rhs.chars();
      else result += __xtd_convert_to_string<xtd::char8>(rhs.chars());
      return result;
    }
#endif
    friend basic_string operator +(const std::basic_string<xtd::wchar>& lhs, const basic_string& rhs) {
      auto result = lhs;
      if constexpr (std::is_same_v<xtd::wchar, char_t>) result += rhs.chars();
      else result += __xtd_convert_to_string<xtd::wchar>(rhs.chars());
      return result;
    }
 
    friend basic_string operator +(const basic_string& lhs, const char* rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
    friend basic_string operator +(const basic_string& lhs, const xtd::char16* rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
    friend basic_string operator +(const basic_string& lhs, const xtd::char32* rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
#if defined(__xtd__cpp_lib_char8_t)
    friend basic_string operator +(const basic_string& lhs, const xtd::char8* rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
#endif
    friend basic_string operator +(const basic_string& lhs, const xtd::wchar* rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
 
    friend basic_string operator +(basic_string&& lhs, const char* rhs) {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }
    friend basic_string operator +(basic_string&& lhs, const xtd::char16* rhs) {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }
    friend basic_string operator +(basic_string&& lhs, const xtd::char32* rhs) {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }
#if defined(__xtd__cpp_lib_char8_t)
    friend basic_string operator +(basic_string&& lhs, const xtd::char8* rhs) {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }
#endif
    friend basic_string operator +(basic_string&& lhs, const xtd::wchar* rhs) {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }
 
    friend basic_string operator +(const char* lhs, const basic_string& rhs) {
      auto result = basic_string(lhs);
      result += rhs;
      return result;
    }
    friend basic_string operator +(const xtd::char16* lhs, const basic_string& rhs) {
      auto result = basic_string(lhs);
      result += rhs;
      return result;
    }
    friend basic_string operator +(const xtd::char32* lhs, const basic_string& rhs) {
      auto result = basic_string(lhs);
      result += rhs;
      return result;
    }
#if defined(__xtd__cpp_lib_char8_t)
    friend basic_string operator +(const xtd::char8* lhs, const basic_string& rhs) {
      auto result = basic_string(lhs);
      result += rhs;
      return result;
    }
#endif
    friend basic_string operator +(const xtd::wchar* lhs, const basic_string& rhs) {
      auto result = basic_string(lhs);
      result += rhs;
      return result;
    }
 
    friend basic_string operator +(const char* lhs, basic_string&& rhs) {
      auto result = basic_string(lhs);
      result += std::move(rhs);
      return result;
    }
    friend basic_string operator +(const xtd::char16* lhs, basic_string&& rhs) {
      auto result = basic_string(lhs);
      result += std::move(rhs);
      return result;
    }
    friend basic_string operator +(const xtd::char32* lhs, basic_string&& rhs) {
      auto result = basic_string(lhs);
      result += std::move(rhs);
      return result;
    }
 
#if defined(__xtd__cpp_lib_char8_t)
    friend basic_string operator +(const xtd::char8* lhs, basic_string&& rhs) {
      auto result = basic_string(lhs);
      result += std::move(rhs);
      return result;
    }
#endif
    friend basic_string operator +(const xtd::wchar* lhs, basic_string&& rhs) {
      auto result = basic_string(lhs);
      result += std::move(rhs);
      return result;
    }
 
    friend basic_string operator +(const basic_string& lhs, const char rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
    friend basic_string operator +(const basic_string& lhs, const xtd::char16 rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
    friend basic_string operator +(const basic_string& lhs, const xtd::char32 rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
#if defined(__xtd__cpp_lib_char8_t)
    friend basic_string operator +(const basic_string& lhs, const xtd::char8 rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
#endif
    friend basic_string operator +(const basic_string& lhs, const xtd::wchar rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }
 
    friend basic_string operator +(basic_string&& lhs, const char rhs) {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }
    friend basic_string operator +(basic_string&& lhs, const xtd::char16 rhs) {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }
    friend basic_string operator +(basic_string&& lhs, const xtd::char32 rhs) {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }
#if defined(__xtd__cpp_lib_char8_t)
    friend basic_string operator +(basic_string&& lhs, const xtd::char8 rhs) {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }
#endif
    friend basic_string operator +(basic_string&& lhs, const xtd::wchar rhs) {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }
 
    friend basic_string operator +(char lhs, const basic_string& rhs) {
      auto result = basic_string(1, lhs);
      result += rhs;
      return result;
    }
    friend basic_string operator +(xtd::char16 lhs, const basic_string& rhs) {
      auto result = basic_string(1, lhs);
      result += rhs;
      return result;
    }
    friend basic_string operator +(xtd::char32 lhs, const basic_string& rhs) {
      auto result = basic_string(1, lhs);
      result += rhs;
      return result;
    }
#if defined(__xtd__cpp_lib_char8_t)
    friend basic_string operator +(xtd::char8 lhs, const basic_string& rhs) {
      auto result = basic_string(1, lhs);
      result += rhs;
      return result;
    }
#endif
    friend basic_string operator +(xtd::wchar lhs, const basic_string& rhs) {
      auto result = basic_string(1, lhs);
      result += rhs;
      return result;
    }
 
    friend basic_string operator +(char lhs, basic_string&& rhs) {
      auto result = basic_string(1, lhs);
      result += std::move(rhs);
      return result;
    }
    friend basic_string operator +(xtd::char16 lhs, basic_string&& rhs) {
      auto result = basic_string(1, lhs);
      result += std::move(rhs);
      return result;
    }
    friend basic_string operator +(xtd::char32 lhs, basic_string&& rhs) {
      auto result = basic_string(1, lhs);
      result += std::move(rhs);
      return result;
    }
#if defined(__xtd__cpp_lib_char8_t)
    friend basic_string operator +(xtd::char8 lhs, basic_string&& rhs) {
      auto result = basic_string(1, lhs);
      result += std::move(rhs);
      return result;
    }
#endif
    friend basic_string operator +(xtd::wchar lhs, basic_string&& rhs) {
      auto result = basic_string(1, lhs);
      result += std::move(rhs);
      return result;
    }
 
    //friend std::basic_ostream<char>& operator <<(std::basic_ostream<char>& stream, const basic_string& str) {return stream << str.to_string().chars_;}
    friend std::basic_ostream<char>& operator <<(std::basic_ostream<char>& stream, const basic_string& str) {
      if constexpr (std::is_same_v<char, char_t>) return stream << str.chars();
      else return stream << __xtd_convert_to_string<char>(str.chars());
    }
    friend std::basic_ostream<xtd::wchar>& operator <<(std::basic_ostream<xtd::wchar>& stream, const basic_string& str) {return stream << str.to_wstring().chars();}
 
    friend std::basic_istream<char>& operator >>(std::basic_istream<char>& stream, basic_string& str) {
      auto s = std::basic_string<char> {};
      stream >> s;
      str = s;
      return stream;
    }
    friend std::basic_istream<xtd::wchar>& operator >>(std::basic_istream<xtd::wchar>& stream, basic_string& str) {
      auto s = std::basic_string<xtd::wchar> {};
      stream >> s;
      str = s;
      return stream;
    }
 
  private:
    friend class basic_string<char>;
    friend class basic_string<xtd::char16>;
    friend class basic_string<xtd::char32>;
#if defined(__xtd__cpp_lib_char8_t)
    friend class basic_string<xtd::char8>;
#endif
    friend class basic_string<xtd::wchar>;
 
    static const xtd::array<value_type> default_split_separators;
    static const xtd::array<value_type> default_trim_chars;
 
    template<class arg_t>
    static auto convert_param(arg_t&& arg) noexcept {
      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();
      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();
      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();
#if defined(__xtd__cpp_lib_char8_t)
      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();
#endif
      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();
      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();
      else return std::forward<arg_t>(arg);
    }
 
    static basic_string get_class_name(const basic_string& full_name) {
      auto length = full_name.last_index_of("<");
      if (length == npos) length = full_name.length();
      if (full_name.last_index_of("::", 0, length) == npos) return full_name;
      return full_name.substring(full_name.last_index_of("::", 0, length) + 2);
    }
 
    typename base_type::iterator to_base_type_iterator(iterator value) const noexcept {
      if (value == begin()) return chars_.begin();
      if (value == end()) return chars_.end();
      return chars_.begin() + (value - begin());
    }
    
    iterator to_iterator(typename base_type::iterator value) const noexcept {
      if (value == chars_.begin()) return begin();
      if (value == chars_.end()) return end();
      return begin() + (value - chars_.begin());
    }
 
    base_type chars_;
  };
}
 
#define __XTD_BASIC_STRING_INTERNAL__
#include "basic_string_.hpp"
#undef __XTD_BASIC_STRING_INTERNAL__