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 "basic_read_only_string_view.hpp"
#include "basic_string_view.hpp"
#include "character.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 "types.hpp"
#include <cctype>
#include <iomanip>
#include <ostream>
#include <sstream>
#include <string>

template<typename ...args_t>
void __basic_string_extract_format_arg(const std::locale& loc, xtd::basic_string<char>& fmt, xtd::array<__format_information<char >>& formats, args_t&&... args);
template<typename target_t, typename source_t>
std::basic_string<target_t> __xtd_convert_to_string(std::basic_string<source_t>&& str) noexcept;
template<typename target_t, typename 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 {
  struct index;
  class range;
  
  template<typename char_t, typename traits_t, typename 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;
    basic_string(basic_string&&) = default;
    basic_string(std::basic_string<char_t>&& str) : chars_ {std::move(str)} {}
    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_);
    }

    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_);
    }

    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 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);
    }

    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);
    }

    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(char character, xtd::usize count) : basic_string(std::basic_string<char>(count, character)) {}
    basic_string(xtd::char16 character, xtd::usize count) : basic_string(std::basic_string<xtd::char16>(count, character)) {}
    basic_string(xtd::char32 character, xtd::usize count) : basic_string(std::basic_string<xtd::char32>(count, character)) {}
    basic_string(xtd::char8 character, xtd::usize count) : basic_string(std::basic_string<xtd::char8>(count, character)) {}
    basic_string(xtd::wchar character, xtd::usize count) : basic_string(std::basic_string<xtd::wchar>(count, character)) {}
    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));
    }

    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));
    }

    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, xtd::usize 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::usize 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::usize 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));
    }

    basic_string(const xtd::char8* str, xtd::usize 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));
    }

    basic_string(const xtd::wchar* str, xtd::usize 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));
    }

    template<typename input_iterator_t>
    basic_string(input_iterator_t first, input_iterator_t last) : chars_(first, last) {}
    basic_string(const xtd::collections::generic::ienumerable<char_t>& items) : chars_(items.begin(), items.end()) {}
    basic_string(const xtd::basic_string_view<char_t>& str) : chars_(str) {}
    //basic_string(const xtd::basic_read_only_string_view<char_t>& str) : chars_(str) {}
    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)) {}
    basic_string(std::initializer_list<xtd::char8> il) : basic_string(std::basic_string<xtd::char8>(il)) {}
    basic_string(std::initializer_list<xtd::wchar> il) : basic_string(std::basic_string<xtd::wchar>(il)) {}
    
    
    [[nodiscard]] auto c_str() const noexcept -> const_pointer {return chars_.c_str();}
    
    [[nodiscard]] auto chars() const noexcept -> const base_type& {return chars_;}
    [[nodiscard]] auto chars() noexcept -> base_type& {return chars_;}
    
    [[nodiscard]] virtual auto count() const noexcept -> size_type {return chars_.size();}
    
    [[nodiscard]] auto data() const noexcept -> const_pointer {return chars_.data();}
    
    [[nodiscard]] virtual auto empty() const noexcept -> bool {return length() == 0;}
    
    [[nodiscard]] virtual auto length() const noexcept -> size_type {return chars_.size();}
    
    [[nodiscard]] virtual auto size() const noexcept -> size_type {return chars_.size();}
    
    
    [[nodiscard]] auto compare_to(const object& value) const -> xtd::int32 {
      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));
    }

    [[nodiscard]] auto compare_to(const basic_string& value) const noexcept -> xtd::int32 override {return chars_.compare(value.chars_);}
    
    [[nodiscard]] virtual auto contains(value_type value) const noexcept -> bool {return chars_.find(value) != npos;}
    [[nodiscard]] virtual auto contains(const basic_string& value) const noexcept -> bool {return chars_.find(value) != npos;}
    
    [[nodiscard]] auto equals(const object& obj) const noexcept -> bool override {return dynamic_cast<const basic_string*>(&obj) && equals(static_cast<const basic_string&>(obj));}
    [[nodiscard]] auto equals(const basic_string& value) const noexcept -> bool override {return equals(value, false);}
    [[nodiscard]] auto equals(const basic_string& value, bool ignore_case) const noexcept -> bool {
      if (ignore_case) return to_upper().chars_ == value.to_upper().chars_;
      return chars_ == value.chars_;
    }
    
    [[nodiscard]] auto ends_with(value_type value) const noexcept -> bool {return ends_with(value, false);}
    [[nodiscard]] auto ends_with(value_type value, bool ignore_case) const noexcept -> bool {
      if (ignore_case) return to_lower().chars_.rfind(static_cast<value_type>(tolower(value))) == length() - 1;
      return chars_.rfind(value) == length() - 1;
    }

    [[nodiscard]] auto ends_with(const basic_string& value) const noexcept -> bool {return ends_with(value, xtd::string_comparison::ordinal);}
    [[nodiscard]] auto ends_with(const basic_string& value, bool ignore_case) const noexcept -> bool {return ends_with(value, ignore_case ? xtd::string_comparison::ordinal_ignore_case : xtd::string_comparison::ordinal);}
    [[nodiscard]] auto ends_with(const basic_string& value, xtd::string_comparison comparison_type) const noexcept -> bool {
      if (comparison_type == xtd::string_comparison::ordinal_ignore_case) return to_lower().chars_.rfind(value.to_lower()) + value.to_lower().length() == length();
      return chars_.rfind(value) + value.length() == length();
    }
       
    [[nodiscard]] virtual auto get_base_type() const noexcept -> const base_type& {return chars_;}
    
    [[nodiscard]] auto get_hash_code() const noexcept -> xtd::usize override {return xtd::hash_code::combine(chars_);}
    
    [[nodiscard]] auto get_enumerator() const noexcept -> enumerator_type override {
      struct basic_string_enumerator : public xtd::collections::generic::ienumerator<value_type> {
        explicit basic_string_enumerator(const basic_string& chars) : chars_(chars) {}
        [[nodiscard]] const value_type& current() const override {
          if (index_ >= chars_.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
          return chars_[index_];
        }
        bool move_next() override {return ++index_ < chars_.length();}
        void reset() override {index_ = basic_string::npos;}
        
      private:
        const basic_string& chars_;
        size_type index_ = basic_string::npos;
      };
      return {new_ptr<basic_string_enumerator>(self_)};
    }
    
    [[nodiscard]] auto index_of(const basic_string& value) const noexcept -> xtd::usize {return index_of(value, 0, length());}
    [[nodiscard]] auto index_of(const basic_string& value, xtd::usize start_index) const -> xtd::usize {return index_of(value, start_index, length() - start_index);}
    [[nodiscard]] auto index_of(const basic_string& value, xtd::usize start_index, xtd::usize count) const -> xtd::usize {
      if (start_index > length() || start_index + count > length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      auto result = chars_.find(value, start_index);
      return result > start_index + count ? npos : result;
    }

    [[nodiscard]] auto index_of(value_type value) const noexcept -> xtd::usize {return index_of(value, 0, length());}
    [[nodiscard]] auto index_of(value_type value, xtd::usize start_index) const -> xtd::usize {return index_of(value, start_index, length() - start_index);}
    [[nodiscard]] auto index_of(value_type value, xtd::usize start_index, xtd::usize count) const -> xtd::usize {
      if (start_index > length() || start_index + count > length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      auto result = chars_.find(value, start_index);
      return result > start_index + count ? npos : result;
    }
    
    [[nodiscard]] auto index_of_any(const xtd::array<value_type>& values) const noexcept -> xtd::usize;
    [[nodiscard]] auto index_of_any(const xtd::array<value_type>& values, xtd::usize start_index) const -> xtd::usize;
    [[nodiscard]] auto index_of_any(const xtd::array<value_type>& values, xtd::usize start_index, xtd::usize count) const -> xtd::usize;
    [[nodiscard]] auto index_of_any(const std::initializer_list<value_type>& values) const noexcept -> xtd::usize;
    [[nodiscard]] auto index_of_any(const std::initializer_list<value_type>& values, xtd::usize start_index) const -> xtd::usize;
    [[nodiscard]] auto index_of_any(const std::initializer_list<value_type>& values, xtd::usize start_index, xtd::usize count) const -> xtd::usize;
    
    auto insert(xtd::usize start_index, const basic_string& value) const -> basic_string {
      if (start_index > length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      auto result = self_;
      result.chars_.insert(start_index, value);
      return result;
    }
    
    [[nodiscard]] auto last_index_of(const basic_string& value) const noexcept -> xtd::usize {return last_index_of(value, 0, length());}
    [[nodiscard]] auto last_index_of(const basic_string& value, xtd::usize start_index) const -> xtd::usize {return last_index_of(value, start_index, length() - start_index);}
    [[nodiscard]] auto last_index_of(const basic_string& value, xtd::usize start_index, xtd::usize count) const -> xtd::usize {
      if (start_index > length() || start_index + count > length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      auto result = chars_.rfind(value, start_index + count - value.length());
      return result < start_index ? npos : result;
    }

    [[nodiscard]] auto last_index_of(value_type value) const noexcept -> xtd::usize {return last_index_of(value, 0, length());}
    [[nodiscard]] auto last_index_of(value_type value, xtd::usize start_index) const -> xtd::usize {return last_index_of(value, start_index, length() - start_index);}
    [[nodiscard]] auto last_index_of(value_type value, xtd::usize start_index, xtd::usize count) const -> xtd::usize {
      if (start_index > length() || start_index + count > length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      auto result = chars_.rfind(value, start_index + count - 1);
      return result < start_index ? npos : result;
    }
    
    [[nodiscard]] auto last_index_of_any(const xtd::array<value_type>& values) const noexcept -> xtd::usize;
    [[nodiscard]] auto last_index_of_any(const xtd::array<value_type>& values, xtd::usize start_index) const -> xtd::usize;
    [[nodiscard]] auto last_index_of_any(const xtd::array<value_type>& values, xtd::usize start_index, xtd::usize count) const -> xtd::usize;
    [[nodiscard]] auto last_index_of_any(const std::initializer_list<value_type>& values) const noexcept -> xtd::usize;
    [[nodiscard]] auto last_index_of_any(const std::initializer_list<value_type>& values, xtd::usize start_index) const -> xtd::usize;
    [[nodiscard]] auto last_index_of_any(const std::initializer_list<value_type>& values, xtd::usize start_index, xtd::usize count) const -> xtd::usize;
    
    [[nodiscard]] auto pad_left(xtd::usize total_width) const noexcept -> basic_string {return pad_left(total_width, ' ');}
    [[nodiscard]] auto pad_left(xtd::usize total_width, char32 padding_char) const noexcept -> basic_string {return total_width < length() ? self_ : basic_string(padding_char, total_width - length()) + self_;}
    
    [[nodiscard]] auto pad_right(xtd::usize total_width) const noexcept -> basic_string {return pad_right(total_width, ' ');}
    [[nodiscard]] auto pad_right(xtd::usize total_width, char32 padding_char) const noexcept -> basic_string {return total_width < length() ? self_ : self_ + basic_string(padding_char, total_width - length());}
    
    [[nodiscard]] auto quoted() const -> basic_string {return quoted('"', '\\');}
    [[nodiscard]] auto quoted(value_type delimiter) const -> basic_string {return quoted(delimiter, '\\');}
    [[nodiscard]] auto quoted(value_type delimiter, value_type escape) const -> basic_string {
      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();
    }
    
    [[nodiscard]] auto remove(xtd::usize start_index) const -> basic_string {return remove(start_index, length() - start_index);}
    [[nodiscard]] auto remove(xtd::usize start_index, xtd::usize count) const -> basic_string {
      if (start_index > length() || start_index + count > length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      auto result = self_;
      result.chars_.erase(start_index, count);
      return result;
    }
    
    [[nodiscard]] auto replace(value_type old_char, value_type new_char) const noexcept -> basic_string {return replace(string(old_char, 1), string(new_char, 1));}
    [[nodiscard]] auto replace(const basic_string& old_string, const basic_string& new_string) const noexcept -> basic_string {
      auto result = self_;
      auto old_size = old_string.length();
      auto new_size = new_string.length();
      auto index = xtd::usize {0};
      while (true) {
        index = result.chars_.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.length());
          result.chars_.insert(index, new_string);
        }
        index += new_string.length();
      }
      return result;
    }
    
    [[nodiscard]] auto split() const noexcept -> xtd::array<basic_string>;
    [[nodiscard]] auto split(value_type separator) const noexcept -> xtd::array<basic_string>;
    [[nodiscard]] auto split(value_type separator, xtd::string_split_options options) const noexcept -> xtd::array<basic_string>;
    [[nodiscard]] auto split(value_type separator, xtd::usize count) const noexcept -> xtd::array<basic_string>;
    [[nodiscard]] auto split(value_type separator, xtd::usize count, xtd::string_split_options options) const noexcept -> xtd::array<basic_string>;
    [[nodiscard]] auto split(const xtd::array<value_type>& separators) const noexcept -> xtd::array<basic_string>;
    [[nodiscard]] auto split(const xtd::array<value_type>& separators, xtd::string_split_options options) const noexcept -> xtd::array<basic_string>;
    [[nodiscard]] auto split(const xtd::array<value_type>& separators, xtd::usize count) const noexcept -> xtd::array<basic_string>;
    [[nodiscard]] auto split(const xtd::array<value_type>& separators, xtd::usize count, xtd::string_split_options options) const noexcept -> xtd::array<basic_string>;
    
    [[nodiscard]] bool starts_with(value_type value) const noexcept {return starts_with(value, false);}
    [[nodiscard]] bool starts_with(value_type value, bool ignore_case) const noexcept {
      if (ignore_case) return to_lower().chars_.find(static_cast<value_type>(tolower(value))) == 0;
      return chars_.find(value) == 0;
    }

    [[nodiscard]] auto starts_with(const basic_string& value) const noexcept -> bool {return starts_with(value, string_comparison::ordinal);}
    [[nodiscard]] auto starts_with(const basic_string& value, bool ignore_case) const noexcept -> bool {return starts_with(value, ignore_case ? string_comparison::ordinal_ignore_case : string_comparison::ordinal);}
    [[nodiscard]] auto starts_with(const basic_string& value, xtd::string_comparison comparison_type) const noexcept -> bool {
      if (comparison_type == xtd::string_comparison::ordinal_ignore_case) return to_lower().chars_.find(value.to_lower()) == 0;
      return chars_.find(value) == 0;
    }
    
    [[nodiscard]] auto substring(xtd::usize start_index) const -> basic_string {
      if (start_index > length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return chars_.substr(start_index);
    }

    [[nodiscard]] auto substring(xtd::usize start_index, xtd::usize length) const -> basic_string {
      if (start_index > self_.length() || start_index + length > self_.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return chars_.substr(start_index, length);
    }
    
    [[nodiscard]] auto to_array() const noexcept -> xtd::array<value_type>;
    [[nodiscard]] auto to_array(xtd::usize start_index) const -> xtd::array<value_type>;
    [[nodiscard]] auto to_array(xtd::usize start_index, xtd::usize length) const -> xtd::array<value_type>;
    
    [[nodiscard]] auto to_char_array() const noexcept -> xtd::array<value_type>;
    [[nodiscard]] auto to_char_array(xtd::usize start_index, xtd::usize length) const -> xtd::array<value_type>;
    
    [[nodiscard]] auto to_lower() const noexcept -> basic_string {
      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;
    }
    
    [[nodiscard]] auto to_string() const noexcept -> basic_string<char> override {
      if constexpr(std::is_same_v<char, char_t>) return chars_;
      else return __xtd_convert_to_string<char>(chars_);
    }
    
    [[nodiscard]] auto to_title_case() const noexcept -> basic_string;
    
    [[nodiscard]] auto to_u16string() const noexcept -> basic_string<xtd::char16> {
      if constexpr(std::is_same_v<xtd::char16, char_t>) return chars_;
      else return __xtd_convert_to_string<xtd::char16>(chars_);
    }
    
    [[nodiscard]] auto to_u32string() const noexcept -> basic_string<xtd::char32> {
      if constexpr(std::is_same_v<xtd::char32, char_t>) return chars_;
      else return __xtd_convert_to_string<xtd::char32>(chars_);
    }
    
    [[nodiscard]] auto to_u8string() const noexcept -> basic_string<xtd::char8> {
      if constexpr(std::is_same_v<xtd::char8, char_t>) return chars_;
      else return __xtd_convert_to_string<xtd::char8>(chars_);
    }
    
    [[nodiscard]] auto to_upper() const noexcept -> basic_string {
      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;
    }
    
    [[nodiscard]] auto to_wstring() const noexcept -> basic_string<xtd::wchar> {
      if constexpr(std::is_same_v<xtd::wchar, char_t>) return chars_;
      else return __xtd_convert_to_string<xtd::wchar>(chars_);
    }
    
    [[nodiscard]] auto trim() const noexcept -> basic_string {return trim(default_trim_chars);}
    [[nodiscard]] auto trim(value_type trim_char) const noexcept -> basic_string;
    [[nodiscard]] auto trim(const xtd::array<value_type>& trim_chars) const noexcept -> basic_string;
    
    [[nodiscard]] auto trim_end() const noexcept -> basic_string {return trim_end(default_trim_chars);}
    [[nodiscard]] auto trim_end(value_type trim_char) const noexcept -> basic_string;
    [[nodiscard]] auto trim_end(const xtd::array<value_type>& trim_chars) const noexcept -> basic_string;
    
    [[nodiscard]] auto trim_start() const noexcept -> basic_string {return trim_start(default_trim_chars);}
    [[nodiscard]] auto trim_start(value_type trim_char) const noexcept -> basic_string;
    [[nodiscard]] auto trim_start(const xtd::array<value_type>& trim_chars) const noexcept -> basic_string;
    
    
    [[nodiscard]] static auto compare(const basic_string& str_a, const basic_string& str_b) noexcept -> xtd::int32 {return compare(str_a, str_b, false);}
    [[nodiscard]] static auto compare(const basic_string& str_a, const basic_string& str_b, bool ignore_case) noexcept -> xtd::int32 {return compare(str_a, str_b, ignore_case ? xtd::string_comparison::ordinal_ignore_case : xtd::string_comparison::ordinal);}
    [[nodiscard]] static auto compare(const basic_string& str_a, const basic_string& str_b, xtd::string_comparison comparison_type) noexcept -> xtd::int32 {return comparison_type == xtd::string_comparison::ordinal_ignore_case ? str_a.to_lower().chars_.compare(str_b.to_lower()) : str_a.chars_.compare(str_b);}
    [[nodiscard]] static auto compare(const basic_string& str_a, xtd::usize index_a, const basic_string& str_b, xtd::usize index_b, xtd::usize length) -> xtd::int32 {return compare(str_a, index_a, str_b, index_b, length, false);}
    [[nodiscard]] static auto compare(const basic_string& str_a, xtd::usize index_a, const basic_string& str_b, xtd::usize index_b, xtd::usize length, bool ignore_case) -> xtd::int32 {return compare(str_a, index_a, str_b, index_b, length, ignore_case ? xtd::string_comparison::ordinal_ignore_case : xtd::string_comparison::ordinal);}
    [[nodiscard]] static auto compare(const basic_string& str_a, xtd::usize index_a, const basic_string& str_b, xtd::usize index_b, xtd::usize length, xtd::string_comparison comparison_type) -> xtd::int32 {return comparison_type == xtd::string_comparison::ordinal_ignore_case ? str_a.substring(index_a, length).to_lower().chars_.compare(str_b.substring(index_b, length).to_lower()) : str_a.substring(index_a, length).chars_.compare(str_b.substring(index_b, length));}
    
    [[nodiscard]] static auto concat(const basic_string& str_a, const basic_string& str_b, const basic_string& str_c, const basic_string& str_d) noexcept -> basic_string {return str_a + str_b + str_c + str_d;}
    template<typename object_a_t, typename object_b_t, typename object_c_t, typename object_d_t>
    [[nodiscard]] static auto concat(object_a_t obj_a, object_b_t obj_b, object_c_t obj_c, object_d_t obj_d) noexcept -> basic_string {return format("{}{}{}{}", obj_a, obj_b, obj_c, obj_d);}
    [[nodiscard]] static auto concat(const basic_string& str_a, const basic_string& str_b, const basic_string& str_c) noexcept -> basic_string {return str_a + str_b + str_c;}
    template<typename object_a_t, typename object_b_t, typename object_c_t>
    [[nodiscard]] static auto concat(object_a_t obj_a, object_b_t obj_b, object_c_t obj_c) noexcept -> basic_string {return format("{}{}{}", obj_a, obj_b, obj_c);}
    [[nodiscard]] static auto concat(const basic_string& str_a, const basic_string& str_b) noexcept -> basic_string {return str_a + str_b;}
    template<typename object_a_t, typename object_b_t>
    [[nodiscard]] static auto concat(object_a_t obj_a, object_b_t obj_b) noexcept -> basic_string {return format("{}{}", obj_a, obj_b);}
    [[nodiscard]] static auto concat(const xtd::array<basic_string>& values) noexcept -> basic_string;
    [[nodiscard]] static auto concat(const xtd::array<const_pointer>& values) noexcept -> basic_string;
    template<typename other_char_t>
    [[nodiscard]] static auto concat(const xtd::array<const other_char_t*>& values) noexcept -> basic_string;
    [[nodiscard]] static auto concat(const std::initializer_list<basic_string>& values) noexcept -> basic_string {
      auto result = basic_string::empty_string;
      std::for_each(values.begin(), values.end(), [&](const auto& item) {result += item;});
      return result;
    }
    [[nodiscard]] static auto concat(const std::initializer_list<const_pointer>& values) noexcept -> basic_string {
      auto result = basic_string::empty_string;
      std::for_each(values.begin(), values.end(), [&](const auto& item) {result += item;});
      return result;
    }
    template<typename other_char_t>
    [[nodiscard]] static auto concat(const std::initializer_list<const other_char_t*>& values) noexcept -> basic_string {
      auto result = basic_string::empty_string;
      std::for_each(values.begin(), values.end(), [&](const auto& item) {result += item;});
      return result;
    }
    template<typename object_t>
    [[nodiscard]] static auto concat(const xtd::array<object_t>& args) noexcept -> basic_string;
    template<typename object_t>
    [[nodiscard]] static auto concat(const std::initializer_list<object_t>& args) noexcept -> basic_string {
      basic_string result;
      for (const auto& arg : args)
        result += format("{}", arg);
      return result;
    }
    template<typename value_t>
    [[nodiscard]] static auto concat(value_t value) noexcept -> basic_string {
      return format("{}", value);
    }
    
    [[nodiscard]] static auto demangle(const basic_string& name) -> basic_string {
      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()));
    }
    
    [[nodiscard]] static auto equals(const basic_string& a, const basic_string& b) noexcept -> bool {return a.equals(b);}
    template<typename char_a_t, typename char_b_t>
    [[nodiscard]] static auto equals(const char_a_t* a, const char_b_t* b) noexcept -> bool {return basic_string {a}.equals(basic_string {b});}
    
    [[nodiscard]] static auto equals(const basic_string& a, const basic_string& b, bool ignore_case) noexcept -> bool {return a.equals(b, ignore_case);}
    template<typename char_a_t, typename char_b_t>
    [[nodiscard]] static auto equals(const char_a_t* a, const char_b_t* b, bool ignore_case) noexcept -> bool {return basic_string {a}.equals(basic_string {b}, ignore_case);}
    
    template<typename ...args_t>
    [[nodiscard]] static auto format(const basic_string<char>& fmt, args_t&& ... args) -> basic_string;
    
    template<typename ...args_t>
    [[nodiscard]] static auto format(const std::locale& loc, const basic_string<char>& fmt, args_t&& ... args) -> basic_string;
    
    [[nodiscard]] static auto is_empty(const xtd::basic_string<value_type, traits_type, allocator_type>& string) noexcept -> bool {return !string.length();}
    
    template<typename collection_t>
    [[nodiscard]] static auto join(const basic_string& separator, const collection_t& values) noexcept -> basic_string {
      xtd::usize i = 0;
      basic_string result;
      for (const auto& item : values)
        result += format("{}{}", (i++ != 0 ? separator : basic_string {}), item);
      return result;
    }

    template<typename collection_t>
    [[nodiscard]] static auto join(const basic_string& separator, const collection_t& values, xtd::usize index) -> basic_string {return join(separator, values, index, values.size() - index);}
    template<typename collection_t>
    [[nodiscard]] static auto join(const basic_string& separator, const collection_t& values, xtd::usize index, xtd::usize count) -> basic_string {
      if (index > values.size() || index + count > values.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      xtd::usize 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<typename value_t>
    [[nodiscard]] static auto join(const basic_string& separator, const std::initializer_list<value_t>& values) noexcept -> basic_string;
    template<typename value_t>
    [[nodiscard]] static auto join(const basic_string& separator, const std::initializer_list<value_t>& values, xtd::usize index) -> basic_string;
    template<typename value_t>
    [[nodiscard]] static auto join(const basic_string& separator, const std::initializer_list<value_t>& values, xtd::usize index, xtd::usize count) -> basic_string;
    
    template<typename value_t>
    [[nodiscard]] static auto parse(const basic_string& str) -> value_t {
      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<typename ...args_t>
    [[nodiscard]] static auto sprintf(const basic_string& fmt, args_t&& ... args) noexcept -> basic_string {return __sprintf(fmt.chars().c_str(), convert_param(std::forward<args_t>(args)) ...);}
    
    template<typename value_t>
    [[nodiscard]] static auto try_parse(const basic_string& str, value_t& value) noexcept -> bool {
      try {
        value = parse<value_t>(str);
        return true;
      } catch (...) {
        return false;
      }
    }

    
    
    auto operator [](xtd::usize index) const -> const_reference {
      if (index >= length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      return chars_[index];
    }

    auto operator [](const xtd::index& index) const -> const_reference;
    auto operator [](const xtd::range& range) const -> xtd::basic_read_only_string_view<char_t>;

    auto operator ()(xtd::usize index) const -> const_reference {
      return operator [](index);
    }

    auto operator ()(const xtd::index& index) const -> const_reference;
    auto operator ()(const xtd::range& range) const -> xtd::basic_read_only_string_view<char_t>;

    operator const base_type& () const noexcept {return chars_;}
    
    auto operator =(const basic_string<char>& str) noexcept -> basic_string& {
      if constexpr(std::is_same<char_t, char>::value) chars_ = str.chars_;
      else chars_ = __xtd_convert_to_string<value_type>(str.chars());
      return self_;
    }

    auto operator =(const basic_string<xtd::char16>& str) noexcept -> basic_string& {
      if constexpr(std::is_same<char_t, xtd::char16>::value) chars_ = str.chars_;
      else chars_ = __xtd_convert_to_string<value_type>(str.chars());
      return self_;
    }

    auto operator =(const basic_string<xtd::char32>& str) noexcept -> basic_string& {
      if constexpr(std::is_same<char_t, xtd::char32>::value) chars_ = str.chars_;
      else chars_ = __xtd_convert_to_string<value_type>(str.chars());
      return self_;
    }

    auto operator =(const basic_string<xtd::char8>& str) noexcept -> basic_string& {
      if constexpr(std::is_same<char_t, xtd::char8>::value) chars_ = str.chars_;
      else chars_ = __xtd_convert_to_string<value_type>(str.chars());
      return self_;
    }

    auto operator =(const basic_string<xtd::wchar>& str) noexcept -> basic_string& {
      if constexpr(std::is_same<char_t, xtd::wchar>::value) chars_ = str.chars_;
      else chars_ = __xtd_convert_to_string<value_type>(str.chars());
      return self_;
    }
    
    auto operator =(basic_string<char>&& str) noexcept -> basic_string& {
      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 self_;
    }

    auto operator =(basic_string<xtd::char16>&& str) noexcept -> basic_string& {
      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 self_;
    }

    auto operator =(basic_string<xtd::char32>&& str) noexcept -> basic_string& {
      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 self_;
    }

    auto operator =(basic_string<xtd::char8>&& str) noexcept -> basic_string& {
      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 self_;
    }

    auto operator =(basic_string<xtd::wchar>&& str) noexcept -> basic_string& {
      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 self_;
    }
    
    auto operator =(const std::basic_string<char>& str) noexcept -> basic_string& {
      if constexpr(std::is_same<char_t, char>::value) chars_ = str;
      else chars_ = __xtd_convert_to_string<value_type>(str);
      return self_;
    }

    auto operator =(const std::basic_string<xtd::char16>& str) noexcept -> basic_string& {
      if constexpr(std::is_same<char_t, xtd::char16>::value) chars_ = str;
      else chars_ = __xtd_convert_to_string<value_type>(str);
      return self_;
    }

    auto operator =(const std::basic_string<xtd::char32>& str) noexcept -> basic_string& {
      if constexpr(std::is_same<char_t, xtd::char32>::value) chars_ = str;
      else chars_ = __xtd_convert_to_string<value_type>(str);
      return self_;
    }

    auto operator =(const std::basic_string<xtd::char8>& str) noexcept -> basic_string& {
      if constexpr(std::is_same<char_t, xtd::char8>::value) chars_ = str;
      else chars_ = __xtd_convert_to_string<value_type>(str);
      return self_;
    }

    auto operator =(const std::basic_string<xtd::wchar>& str) noexcept -> basic_string& {
      if constexpr(std::is_same<char_t, xtd::wchar>::value) chars_ = str;
      else chars_ = __xtd_convert_to_string<value_type>(str);
      return self_;
    }
    
    auto operator =(std::basic_string<char>&& str) noexcept -> basic_string& {
      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 self_;
    }

    auto operator =(std::basic_string<xtd::char16>&& str) noexcept -> basic_string& {
      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 self_;
    }

    auto operator =(std::basic_string<xtd::char32>&& str) noexcept -> basic_string& {
      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 self_;
    }

    auto operator =(std::basic_string<xtd::char8>&& str) noexcept -> basic_string& {
      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 self_;
    }

    auto operator =(std::basic_string<xtd::wchar>&& str) noexcept -> basic_string& {
      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 self_;
    }
    
    auto operator =(const char* str) -> basic_string& {
      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 self_;
    }

    auto operator =(const xtd::char16* str) -> basic_string& {
      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 self_;
    }

    auto operator =(const xtd::char32* str) -> basic_string& {
      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 self_;
    }

    auto operator =(const xtd::char8* str) -> basic_string& {
      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 self_;
    }

    auto operator =(const xtd::wchar* str) -> basic_string& {
      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 self_;
    }
    
    auto operator =(char character) -> basic_string& {
      self_ = basic_string(character, 1);
      return  self_;
    }

    auto operator =(xtd::char16 character) -> basic_string& {
      self_ = basic_string(character, 1);
      return  self_;
    }

    auto operator =(xtd::char32 character) -> basic_string& {
      self_ = basic_string(character, 1);
      return  self_;
    }

    auto operator =(xtd::char8 character) -> basic_string& {
      self_ = basic_string(character, 1);
      return  self_;
    }

    auto operator =(xtd::wchar character) -> basic_string& {
      self_ = basic_string(character, 1);
      return  self_;
    }
    
    auto operator =(const std::initializer_list<char>& il) -> basic_string& {
      self_ = basic_string(il);
      return self_;
    }

    auto operator =(const std::initializer_list<xtd::char16>& il) -> basic_string& {
      self_ = basic_string(il);
      return self_;
    }

    auto operator =(const std::initializer_list<xtd::char32>& il) -> basic_string& {
      self_ = basic_string(il);
      return self_;
    }

    auto operator =(const std::initializer_list<xtd::char8>& il) -> basic_string& {
      self_ = basic_string(il);
      return self_;
    }

    auto operator =(const std::initializer_list<xtd::wchar>& il) -> basic_string& {
      self_ = basic_string(il);
      return self_;
    }
    
    template<xtd::character other_char_t>
    auto operator +=(const basic_string<other_char_t>& str) -> basic_string& {
      if constexpr(std::is_same_v<other_char_t, char_t>) chars_ += str.chars_;
      else chars_ += __xtd_convert_to_string<value_type>(str.chars_);
      return self_;
    }
    
    template<xtd::character other_char_t>
    auto operator +=(basic_string<other_char_t>&& str) -> basic_string& {
      if constexpr(std::is_same_v<other_char_t, char_t>) chars_ += std::move(str.chars_);
      else chars_ += __xtd_convert_to_string<value_type>(std::move(str.chars_));
      return self_;
    }
    
    template<xtd::character other_char_t>
    auto operator +=(const std::basic_string<other_char_t>& str) -> basic_string& {
      if constexpr(std::is_same_v<other_char_t, char_t>) chars_ += str;
      else chars_ += __xtd_convert_to_string<value_type>(str);
      return self_;
    }
    
    template<xtd::character other_char_t>
    auto operator +=(const other_char_t* str) -> basic_string& {
      chars_ += basic_string(str).chars_;
      return self_;
    }

    template<xtd::character other_char_t>
    auto operator +=(other_char_t ch) -> basic_string& {
      chars_ += basic_string(ch, 1).chars_;
      return self_;
    }
    
    template<xtd::character other_char_t>
    friend auto operator +(const basic_string& lhs, const basic_string<other_char_t>& rhs) -> basic_string {
      auto result = lhs;
      result += rhs;
      return result;
    }
    
    template<xtd::character other_char_t>
    friend auto operator +(basic_string&& lhs, basic_string<other_char_t>&& rhs) -> basic_string {
      auto result = std::move(lhs);
      result += std::move(rhs);
      return result;
    }
    
    template<xtd::character other_char_t>
    friend auto operator +(basic_string&& lhs, const basic_string<other_char_t>& rhs) -> basic_string {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }
    
    template<xtd::character other_char_t>
    friend auto operator +(const basic_string& lhs, basic_string<other_char_t>&& rhs) -> basic_string {
      auto result = lhs;
      result += std::move(rhs);
      return result;
    }
    
    template<xtd::character other_char_t>
    friend auto operator +(const basic_string& lhs, const std::basic_string<other_char_t>& rhs) -> basic_string {
      auto result = lhs;
      result += rhs;
      return result;
    }
    
    template<xtd::character other_char_t>
    friend auto operator +(const std::basic_string<other_char_t>& lhs, const basic_string& rhs) -> basic_string {
      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;
    }
    
    template<xtd::character other_char_t>
    friend auto operator +(const basic_string& lhs, const other_char_t* rhs) -> basic_string {
      auto result = lhs;
      result += rhs;
      return result;
    }
    
    template<xtd::character other_char_t>
    friend auto operator +(basic_string&& lhs, const other_char_t* rhs) -> basic_string {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }
    
    template<xtd::character other_char_t>
    friend auto operator +(const other_char_t* lhs, const basic_string& rhs) -> basic_string {
      auto result = basic_string(lhs);
      result += rhs;
      return result;
    }
    
    template<xtd::character other_char_t>
    friend auto operator +(const other_char_t* lhs, basic_string&& rhs) -> basic_string {
      auto result = basic_string(lhs);
      result += std::move(rhs);
      return result;
    }
    
    template<xtd::character other_char_t>
    friend auto operator +(const basic_string& lhs, other_char_t rhs) -> basic_string {
      auto result = lhs;
      result += rhs;
      return result;
    }
    
    template<xtd::character other_char_t>
    friend auto operator +(basic_string&& lhs, other_char_t rhs) -> basic_string {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }
    
    template<xtd::character other_char_t>
    friend auto operator +(other_char_t lhs, const basic_string& rhs) -> basic_string {
      auto result = basic_string(lhs, 1);
      result += rhs;
      return result;
    }
    
    template<xtd::character other_char_t>
    friend auto operator +(other_char_t lhs, basic_string&& rhs) -> basic_string {
      auto result = basic_string(lhs, 1);
      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 auto operator <<(std::basic_ostream<char>& stream, const basic_string& str) -> std::basic_ostream<char>& {
      if constexpr(std::is_same_v<char, char_t>) return stream << str.chars();
      else return stream << __xtd_convert_to_string<char>(str.chars());
    }

    friend auto operator <<(std::basic_ostream<xtd::wchar>& stream, const basic_string& str) -> std::basic_ostream<xtd::wchar>& {return stream << str.to_wstring().chars();}
    
    friend auto operator >>(std::basic_istream<char>& stream, basic_string& str) -> std::basic_istream<char>& {
      auto s = std::basic_string<char> {};
      stream >> s;
      str = s;
      return stream;
    }

    friend auto operator >>(std::basic_istream<xtd::wchar>& stream, basic_string& str) -> std::basic_istream<xtd::wchar>& {
      auto s = std::basic_string<xtd::wchar> {};
      stream >> s;
      str = s;
      return stream;
    }

    
    
    [[deprecated("Replaced by xtd::basic_string::is_empty(const xtd::basic_string&) - Will be removed in version 1.2.0.")]]
    [[nodiscard]] auto is_empty() const noexcept -> bool {return is_empty(self_);}
    
    
    template<typename object_t>
    [[deprecated("Replaced by typeof_<object_t>().name() - Will be removed in version 1.2.0.")]]
    [[nodiscard]] static auto class_name() -> basic_string {return get_class_name(full_class_name<object_t>());}
    template<typename object_t>
    [[deprecated("Replaced by typeof_(object).name() - Will be removed in version 1.2.0.")]]
    [[nodiscard]] static auto class_name(const object_t& object) -> basic_string {return get_class_name(full_class_name(object));}
    [[deprecated("Replaced by typeof_(info).name() - Will be removed in version 1.2.0.")]]
    [[nodiscard]] static auto class_name(const std::type_info& info) -> basic_string {return __xtd_get_class_name(info);}
    template<typename object_t>
    [[deprecated("Replaced by typeof_<object_t>().full_name() - Will be removed in version 1.2.0.")]]
    [[nodiscard]] static auto full_class_name() -> basic_string {return demangle(typeid(object_t).name());}
    template<typename object_t>
    [[deprecated("Replaced by typeof_(object).full_name() - Will be removed in version 1.2.0.")]]
    [[nodiscard]] static auto full_class_name(const object_t& object) -> basic_string {return demangle(typeid(object).name());}
    [[deprecated("Replaced by typeof_(info).full_name() - Will be removed in version 1.2.0.")]]
    [[nodiscard]] static auto full_class_name(const std::type_info& info) -> basic_string {return __xtd_get_full_class_name(info);}
    
  private:
    friend class basic_string<char>;
    friend class basic_string<xtd::char16>;
    friend class basic_string<xtd::char32>;
    friend class basic_string<xtd::char8>;
    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<typename arg_t>
    [[nodiscard]] 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();
      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();
      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);
    }
    
    [[nodiscard]] static auto get_class_name(const basic_string& full_name) -> basic_string {
      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);
    }
    
    base_type chars_;
  };
}
 
#define __XTD_BASIC_STRING_INTERNAL__
#include "basic_string_.hpp"
#undef __XTD_BASIC_STRING_INTERNAL__

namespace std {
  template<typename char_t>
  struct hash<xtd::basic_string<char_t>> {
    auto operator()(const xtd::basic_string<char_t>& s) const noexcept -> xtd::usize {return s.get_hash_code();}
  };
}