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

template<class ...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<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;
    
    static inline constexpr xtd::size bpos = 0;
    
    static inline constexpr xtd::size epos = npos - 1;
    
    
    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::size count) : basic_string(std::basic_string<char>(count, character)) {}
    basic_string(xtd::char16 character, xtd::size count) : basic_string(std::basic_string<xtd::char16>(count, character)) {}
    basic_string(xtd::char32 character, xtd::size count) : basic_string(std::basic_string<xtd::char32>(count, character)) {}
    basic_string(xtd::char8 character, xtd::size count) : basic_string(std::basic_string<xtd::char8>(count, character)) {}
    basic_string(xtd::wchar character, xtd::size 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::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));
    }

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

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

    template<class input_iterator_t>
    basic_string(input_iterator_t first, input_iterator_t last) : chars_(first, last) {}
    basic_string(const std::basic_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)) {}
    
    
    const_pointer c_str() const noexcept {return chars_.c_str();}
    
    const base_type& chars() const noexcept {return chars_;}
    base_type& chars() noexcept {return chars_;}
    
    virtual size_type count() const noexcept {return chars_.size();}
    
    const_pointer data() const noexcept {return chars_.data();}
    
    virtual bool empty() const noexcept {return length() == 0;}
    
    virtual size_type length() const noexcept {return chars_.size();}
    
    virtual size_type size() const noexcept {return chars_.size();}
    
    
    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))) == length() - 1;
      return chars_.rfind(value) == length() - 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().chars_.rfind(value.to_lower()) + value.to_lower().length() == length();
      return chars_.rfind(value) + value.length() == length();
    }
    
    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 {
      struct basic_string_enumerator : public xtd::collections::generic::ienumerator<value_type> {
        explicit basic_string_enumerator(const basic_string & chars) : chars_(chars) {}
        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_)};
    }
    
    xtd::size index_of(const basic_string & value) const noexcept {return index_of(value, 0, length());}
    xtd::size index_of(const basic_string & value, xtd::size start_index) const {return index_of(value, start_index, length() - start_index);}
    xtd::size index_of(const basic_string & value, xtd::size start_index, xtd::size count) const {
      if (start_index > length() || start_index + count > length()) 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, length());}
    xtd::size index_of(value_type value, xtd::size start_index) const {return index_of(value, start_index, length() - start_index);}
    xtd::size index_of(value_type value, xtd::size start_index, xtd::size count) const {
      if (start_index > length() || start_index + count > length()) 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 > 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;
    }
    
    xtd::size last_index_of(const basic_string & value) const noexcept {return last_index_of(value, 0, length());}
    xtd::size last_index_of(const basic_string & value, xtd::size start_index) const {return last_index_of(value, start_index, length() - start_index);}
    xtd::size last_index_of(const basic_string & value, xtd::size start_index, xtd::size count) const {
      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;
    }

    xtd::size last_index_of(value_type value) const noexcept {return last_index_of(value, 0, length());}
    xtd::size last_index_of(value_type value, xtd::size start_index) const {return last_index_of(value, start_index, length() - start_index);}
    xtd::size last_index_of(value_type value, xtd::size start_index, xtd::size count) const {
      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;
    }
    
    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 < length() ? self_ : basic_string(padding_char, total_width - length()) + self_;}
    
    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 < length() ? self_ : self_ + basic_string(padding_char, total_width - length());}
    
    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, length() - start_index);}
    basic_string remove(xtd::size start_index, xtd::size count) const {
      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;
    }
    
    basic_string replace(value_type old_char, value_type new_char) const noexcept {return replace(string(old_char, 1), string(new_char, 1));}
    basic_string replace(const basic_string & old_string, const basic_string & new_string) const noexcept {
      auto result = self_;
      auto old_size = old_string.length();
      auto new_size = new_string.length();
      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.length());
          result.chars_.insert(index, new_string);
        }
        index += new_string.length();
      }
      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 > length()) 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 > length() || pos + count > length()) 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 > length()) 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 > self_.length() || start_index + length > self_.length()) 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_);
    }
    
    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_);
    }
    
    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;
    
    
    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 ...args_t>
    static basic_string format(const std::locale & loc, const basic_string<char>& fmt, args_t&& ... args);
    
    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.chars().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() && index != epos) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      return chars_[index == epos ? length() - 1 : 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 self_;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    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 self_;
    }
    
    basic_string& operator =(char character) {
      self_ = basic_string(character, 1);
      return  self_;
    }

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

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

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

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

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

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

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

    basic_string& operator =(const std::initializer_list<xtd::wchar>& il) {
      self_ = basic_string(il);
      return self_;
    }
    
    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 self_;
    }

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

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

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

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

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

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

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

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

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

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

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

    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 self_;
    }
    
    basic_string& operator +=(const char* str) {
      chars_ += basic_string(str).chars_;
      return self_;
    }

    basic_string& operator +=(const xtd::char16 * str) {
      chars_.append(basic_string(str).chars_); return self_;
    }

    basic_string& operator +=(const xtd::char32 * str) {
      chars_ += basic_string(str).chars_;
      return self_;
    }

    basic_string& operator +=(const xtd::char8 * str) {
      chars_ += basic_string(str).chars_;
      return self_;
    }

    basic_string& operator +=(const xtd::wchar * str) {
      chars_ += basic_string(str).chars_;
      return self_;
    }

    basic_string& operator +=(char ch) {
      chars_ += basic_string(ch, 1).chars_;
      return self_;
    }

    basic_string& operator +=(xtd::char16 ch) {
      chars_ += basic_string(ch, 1).chars_;
      return self_;
    }

    basic_string& operator +=(xtd::char32 ch) {
      chars_ += basic_string(ch, 1).chars_;
      return self_;
    }

    basic_string& operator +=(xtd::char8 ch) {
      chars_ += basic_string(ch, 1).chars_;
      return self_;
    }

    basic_string& operator +=(xtd::wchar ch) {
      chars_ += basic_string(ch, 1).chars_;
      return self_;
    }
    
    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;
    }

    friend basic_string operator +(const basic_string & lhs, const basic_string<xtd::char8>& rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }

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

    friend basic_string operator +(basic_string&& lhs, basic_string<xtd::char8>&& rhs) {
      auto result = std::move(lhs);
      result += std::move(rhs);
      return result;
    }

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

    friend basic_string operator +(basic_string&& lhs, const basic_string<xtd::char8>& rhs) {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }

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

    friend basic_string operator +(const basic_string & lhs, basic_string<xtd::char8>&& rhs) {
      auto result = lhs;
      result += std::move(rhs);
      return result;
    }

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

    friend basic_string operator +(const basic_string & lhs, const std::basic_string<xtd::char8>& rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }

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

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

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

    friend basic_string operator +(const basic_string & lhs, const xtd::char8 * rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }

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

    friend basic_string operator +(basic_string&& lhs, const xtd::char8 * rhs) {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }

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

    friend basic_string operator +(const xtd::char8 * lhs, const basic_string & rhs) {
      auto result = basic_string(lhs);
      result += rhs;
      return result;
    }

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

    friend basic_string operator +(const xtd::char8 * lhs, basic_string&& rhs) {
      auto result = basic_string(lhs);
      result += std::move(rhs);
      return result;
    }

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

    friend basic_string operator +(const basic_string & lhs, const xtd::char8 rhs) {
      auto result = lhs;
      result += rhs;
      return result;
    }

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

    friend basic_string operator +(basic_string&& lhs, const xtd::char8 rhs) {
      auto result = std::move(lhs);
      result += rhs;
      return result;
    }

    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(lhs, 1);
      result += rhs;
      return result;
    }

    friend basic_string operator +(xtd::char16 lhs, const basic_string & rhs) {
      auto result = basic_string(lhs, 1);
      result += rhs;
      return result;
    }

    friend basic_string operator +(xtd::char32 lhs, const basic_string & rhs) {
      auto result = basic_string(lhs, 1);
      result += rhs;
      return result;
    }

    friend basic_string operator +(xtd::char8 lhs, const basic_string & rhs) {
      auto result = basic_string(lhs, 1);
      result += rhs;
      return result;
    }

    friend basic_string operator +(xtd::wchar lhs, const basic_string & rhs) {
      auto result = basic_string(lhs, 1);
      result += rhs;
      return result;
    }
    
    friend basic_string operator +(char lhs, basic_string&& rhs) {
      auto result = basic_string(lhs, 1);
      result += std::move(rhs);
      return result;
    }

    friend basic_string operator +(xtd::char16 lhs, basic_string&& rhs) {
      auto result = basic_string(lhs, 1);
      result += std::move(rhs);
      return result;
    }

    friend basic_string operator +(xtd::char32 lhs, basic_string&& rhs) {
      auto result = basic_string(lhs, 1);
      result += std::move(rhs);
      return result;
    }

    friend basic_string operator +(xtd::char8 lhs, basic_string&& rhs) {
      auto result = basic_string(lhs, 1);
      result += std::move(rhs);
      return result;
    }

    friend basic_string operator +(xtd::wchar lhs, basic_string&& rhs) {
      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 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;
    }

    
    
    [[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(self_);}
    
    
    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);}
    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);}
    
  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<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();
      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);
    }
    
    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);
    }
    
    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>> {
    xtd::size operator()(const xtd::basic_string<char_t>& s) const noexcept {return s.get_hash_code();}
  };
}