basic_string_builder.h

Go to the documentation of this file.

 
#pragma once
#include "../basic_string.h"
#include "../argument_exception.h"
#include "../argument_out_of_range_exception.h"
#include "../environment.h"
#include "../index_out_of_range_exception.h"
#include "../null_pointer_exception.h"
#include <iterator>
namespace xtd {
  namespace text {
    template<typename char_t, typename traits_t = std::char_traits<char_t>, typename allocator_t = xtd::collections::generic::helpers::allocator<char_t>>
    class basic_string_builder final : public object, public xtd::iequatable<basic_string_builder<char_t, traits_t, allocator_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 base_type::iterator;
      using const_iterator = typename base_type::const_iterator;
      using reverse_iterator = typename base_type::reverse_iterator;
      using const_reverse_iterator = typename base_type::const_reverse_iterator;
      
      
      inline static constexpr size_type npos = base_type::npos;
      
      
      basic_string_builder() = default;
      basic_string_builder(xtd::size capacity) {this->capacity(capacity);}
      basic_string_builder(xtd::size capacity, xtd::size max_capacity) : max_capacity_{max_capacity} {this->capacity(capacity);}
      basic_string_builder(const xtd::basic_string<value_type>& value) : chars_(value.chars()) {}
      basic_string_builder(const xtd::basic_string<value_type>& value, xtd::size capacity) : chars_(value.chars()) {this->capacity(capacity);}
      basic_string_builder(const xtd::basic_string<value_type>& value, xtd::size start_index, xtd::size length, xtd::size capacity) : chars_(value.substring(start_index, length).chars()) {this->capacity(capacity);}
 
      explicit basic_string_builder(const allocator_type& allocator) noexcept : chars_(allocator) {}
      
      basic_string_builder(const basic_string_builder& str) noexcept : chars_(str.chars_) {}
      basic_string_builder(const basic_string_builder& str, const allocator_type& allocator) noexcept : chars_(str.chars_, allocator) {}
      
      basic_string_builder(const basic_string_builder& str, xtd::size index) {
        if (index > str.size()) throw xtd::argument_out_of_range_exception {};
        chars_ = base_type(str.chars_, index);
      }
      basic_string_builder(const basic_string_builder& str, xtd::size index, const allocator_type& allocator) {
        if (index > str.size()) throw xtd::argument_out_of_range_exception {};
        chars_ = base_type(str.chars_, index, allocator);
      }
      
      basic_string_builder(const basic_string_builder& str, xtd::size index, xtd::size count) {
        if (index + count > str.size()) throw xtd::argument_out_of_range_exception {};
        chars_ = base_type(str.chars_, index, count);
      }
      basic_string_builder(const basic_string_builder& str, xtd::size index, xtd::size count, const allocator_type& allocator) {
        if (index + count > str.size()) throw xtd::argument_out_of_range_exception {};
        chars_ = base_type(str.chars_, index, count, allocator);
      }
      
      basic_string_builder(basic_string_builder&& str) noexcept : chars_(std::move(str.chars_)) {}
      basic_string_builder(basic_string_builder&& str, const allocator_type& allocator) noexcept : chars_(std::move(str.chars_), allocator) {}
      
      basic_string_builder(xtd::size count, value_type character) : chars_(count, character) {}
      basic_string_builder(xtd::size count, value_type character, const allocator_type& allocator) : chars_(count, character, allocator) {}
      
      basic_string_builder(value_type character, xtd::size count) : chars_(count, character) {}
      basic_string_builder(value_type character, xtd::size count, const allocator_type& allocator) : chars_(count, character, allocator) {}
 
      basic_string_builder(const_pointer str) {  // Can't be explicit by design.
        if (str == null) throw xtd::null_pointer_exception {};
        chars_ = base_type(str);
      }
      basic_string_builder(const_pointer str, const allocator_type& allocator) {
        if (str == null) throw xtd::null_pointer_exception {};
        chars_ = base_type(str, allocator);
      }
      
      basic_string_builder(const_pointer str, xtd::size count) {
        if (str == null) throw xtd::null_pointer_exception {};
        chars_ = base_type(str, count);
      }
      basic_string_builder(const_pointer str, xtd::size count, const allocator_type& allocator) : chars_(allocator) {
        if (str == null) throw xtd::null_pointer_exception {};
        chars_ = base_type(str, count);
      }
      
      basic_string_builder(const std::basic_string<value_type>& str) noexcept : chars_(str) {}; // Can't be explicit by design.
      basic_string_builder(const std::basic_string<value_type>& str, const allocator_type& allocator) noexcept : chars_(str, allocator) {}
      
      template<typename input_iterator_t>
      basic_string_builder(input_iterator_t first, input_iterator_t last) : chars_(first, last) {}
      template<typename input_iterator_t>
      basic_string_builder(input_iterator_t first, input_iterator_t last, const allocator_type& allocator) : chars_(first, last, allocator) {}
            
      basic_string_builder(std::initializer_list<value_type> il) : chars_(il) {}
      
      basic_string_builder(std::initializer_list<value_type> il, const allocator_type& allocator) : chars_(il, allocator) {}
      
      
      const_reference back() const {return operator[](size() - 1);}
      reference back() {return operator[](size() - 1);}
 
      const_iterator begin() const {return chars_.begin();}
      iterator begin() {return chars_.begin();}
 
      const_pointer c_str() const noexcept {return chars_.c_str();}
      
      size_type capacity() const noexcept {return chars_.capacity();}
      basic_string_builder& capacity(size_type value) {
        reserve(value);
        return *this;
      }
 
      const_iterator cbegin() const {return chars_.cbegin();}
      
      const base_type& chars() const noexcept {return chars_;}
      
      base_type& chars() noexcept {return chars_;}
      
      const_iterator cend() const {return chars_.cend();}
      
      const_pointer data() const noexcept {return chars_.data();}
      pointer data() noexcept {return chars_.data();}
 
      bool empty() const noexcept {return chars_.empty();}
      
      const_iterator end() const {return chars_.end();}
      iterator end() {return chars_.end();}
 
      const_reference front() const {return operator[](0);}
      reference front() {return operator[](0);}
 
      size_type length() const noexcept {return chars_.size();}
      basic_string_builder& length(size_type value) noexcept {
        if (value != length()) resize(value);
        return *this;
      }
 
      size_type max_capacity() const noexcept {return max_capacity_;}
      
      size_type max_size() const noexcept {return chars_.max_size();}
      
      size_type size() const noexcept {return chars_.size();}
      
      
      basic_string_builder& append(const xtd::basic_string<char_t>& value) {return append(basic_string_builder {value});}
      basic_string_builder& append(const xtd::basic_string<char_t>& value, size_type start_index, size_type count) {return append(basic_string_builder {value, start_index, count});}
      basic_string_builder& append(xtd::boolean value) {return append_format("{}", value);}
      basic_string_builder& append(xtd::byte value) {return append_format("{}", value);}
      basic_string_builder& append(xtd::decimal value) {return append_format("{}", value);}
      basic_string_builder& append(double value) {return append_format("{}", value);}
      basic_string_builder& append(xtd::single value) {return append_format("{}", value);}
      basic_string_builder& append(xtd::int16 value) {return append_format("{}", value);}
      basic_string_builder& append(xtd::int32 value) {return append_format("{}", value);}
      basic_string_builder& append(xtd::int64 value) {return append_format("{}", value);}
      basic_string_builder& append(xtd::sbyte value) {return append_format("{}", value);}
      basic_string_builder& append(xtd::uint16 value) {return append_format("{}", value);}
      basic_string_builder& append(xtd::uint32 value) {return append_format("{}", value);}
      basic_string_builder& append(xtd::uint64 value) {return append_format("{}", value);}
      basic_string_builder& append(value_type value) {return append(1_z, value);}
      basic_string_builder& append(value_type value, size_type repeat_count) {return append(repeat_count, value);}
      
      basic_string_builder& append(xtd::slong value) {return append_format("{}", value);}
      basic_string_builder& append(xtd::ulong value) {return append_format("{}", value);}
      
      template<typename object_t>
      basic_string_builder& append(object_t value) {return append_format("{}", value);}
      basic_string_builder& append(size_type count, value_type ch) {return append(basic_string_builder(count, ch));}
      basic_string_builder& append(const basic_string_builder& str) {return append(str, 0, str.length());}
      basic_string_builder& append(const basic_string_builder& str, size_type pos) {return append(str, pos, str.length() - pos);}
      basic_string_builder& append(const basic_string_builder& str, size_type pos, size_type count) {
        if (length() + count > max_capacity()) throw argument_out_of_range_exception {};
        if (pos > str.size() || pos + count > str.length()) throw xtd::argument_out_of_range_exception {};
        chars_.append(str.chars_, pos, count);
        return *this;
      }
      basic_string_builder& append(const_pointer s, size_type count) {return append(basic_string_builder {s, count});}
      basic_string_builder& append(const_pointer s) {return append(basic_string_builder {s});}
      template<class input_iterator_t>
      basic_string_builder& append(input_iterator_t first, input_iterator_t last) {
        if (length() + std::distance(first, last) > max_capacity()) throw argument_out_of_range_exception {};
        return append(basic_string_builder {first, last});
      }
      basic_string_builder& append(std::initializer_list<value_type> ilist) {return append(basic_string_builder {ilist});}
      
      template<typename ...args_t>
      basic_string_builder& append_format(const xtd::basic_string<char_t>& format, args_t&& ... args) {return append(xtd::basic_string<char_t>::format(format, std::forward<args_t>(args)...));}
 
      template<typename collection_t >
      basic_string_builder& append_join(const xtd::basic_string<char_t>& separator, const collection_t &values) {return append(xtd::basic_string<char_t>::join(separator, values));}
      template<typename collection_t >
      basic_string_builder& append_join(value_type separator, const collection_t &values) {return append(xtd::basic_string<char_t>::join(xtd::basic_string<char_t>(1, separator), values));}
 
      template<typename value_t>
      basic_string_builder& append_join(const xtd::basic_string<char_t>& separator, const std::initializer_list<value_t>& values) {return append_join(separator, std::vector<value_t>(values));}
      template<typename value_t>
      basic_string_builder& append_join(value_type separator, const std::initializer_list<value_t>& values) {return append_join(separator, std::vector<value_t>(values));}
 
      basic_string_builder& append_line() {return append(xtd::basic_string<char_t> {xtd::environment::new_line()});}
      basic_string_builder& append_line(const xtd::basic_string<char_t>& value) {return append(value).append_line();}
 
      const_reference at(size_type pos) const {return operator [](pos);}
      reference at(size_type pos) {return operator [](pos);}
 
      basic_string_builder& clear() {
        chars_.clear();
        return *this;
      }
      
      int32 compare(const basic_string_builder& str) const {return chars_.compare(str);}
      int32 compare(size_type pos1, size_type count1, const basic_string_builder& str) const {return chars_.compare(pos1, count1, str);}
      int32 compare(size_type pos1, size_type count1, const basic_string_builder& str, size_type pos2) const {return chars_.compare(pos1, count1, str, pos2);}
      int32 compare(size_type pos1, size_type count1, const basic_string_builder& 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);}
      
      size_type copy(pointer dest, size_type count) const {
        if (count > length()) throw xtd::argument_out_of_range_exception {};
        return chars_.copy(dest, count);
      }
      size_type copy(pointer dest, size_type count, size_type pos) const {
        if (pos > length() || pos + count > length()) throw xtd::argument_out_of_range_exception {};
        return chars_.copy(dest, count, pos);
      }
      
      void copy_to(xtd::size source_index, xtd::array<value_type>& destination, xtd::size destination_index, xtd::size destination_count) const {
        if (source_index > length() || source_index + destination_count > length()) throw xtd::argument_out_of_range_exception {};
        if (destination_index >= destination.size() || destination_index + destination_count > destination.size()) throw xtd::argument_out_of_range_exception {};
        copy(destination.data() + destination_index, destination_count, source_index);
      }
 
      bool equals(const object& obj) const noexcept override {return dynamic_cast<const basic_string_builder*>(&obj) && equals(static_cast<const basic_string_builder&>(obj));}
      bool equals(const basic_string_builder& value) const noexcept override {return chars_ == value.chars_;}
 
      size_type ensure_capacity(size_type capacity) {
        if (this->capacity() < capacity) this->capacity(capacity);
        return this->capacity();
      }
      
      basic_string_builder& erase() {
        chars_.erase();
        return *this;
      }
      basic_string_builder& erase(size_type index) {
        if (index > length()) throw xtd::argument_out_of_range_exception {};
        chars_.erase(index);
        return *this;
      }
      basic_string_builder& erase(size_type index, size_type count) {
        if (index > length() || index + count > length()) throw xtd::argument_out_of_range_exception {};
        chars_.erase(index, count);
        return *this;
      }
      iterator erase(const_iterator position) {return chars_.erase(position);}
      iterator erase(const_iterator first, const_iterator last) {return chars_.erase(first, last);}
 
      size_type find(const basic_string_builder& str) const {return chars_.find(str);}
      size_type find(const basic_string_builder& 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_builder& str) const {return chars_.find_first_of(str);}
      size_type find_first_of(const basic_string_builder& 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(value_type ch) const {return chars_.find_first_of(ch);}
      size_type find_first_of(value_type ch, size_type pos) const {return chars_.find_first_of(ch, pos);}
      
      size_type find_first_not_of(const basic_string_builder& str) const {return chars_.find_first_not_of(str);}
      size_type find_first_not_of(const basic_string_builder& 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(value_type ch) const {return chars_.find_first_not_of(ch);}
      size_type find_first_not_of(value_type ch, size_type pos) const {return chars_.find_first_not_of(ch, pos);}
      
      size_type find_last_of(const basic_string_builder& str) const {return chars_.find_last_of(str);}
      size_type find_last_of(const basic_string_builder& 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(value_type ch) const {return chars_.find_last_of(ch);}
      size_type find_last_of(value_type ch, size_type pos) const {return chars_.find_last_of(ch, pos);}
      
      size_type find_last_not_of(const basic_string_builder& str) const {return chars_.find_last_not_of(str);}
      size_type find_last_not_of(const basic_string_builder& 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(value_type ch) const {return chars_.find_last_not_of(ch);}
      size_type find_last_not_of(value_type 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_);}
 
      basic_string_builder& insert(size_type index, const xtd::basic_string<char_t>& value) {return insert(index, basic_string_builder {value}, 0, value.length());}
      basic_string_builder& insert(size_type index, const xtd::basic_string<char_t>& value, size_type count) {return insert(index, basic_string_builder {value}, 0, count);}
      basic_string_builder& insert(size_type index, xtd::boolean value) {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      basic_string_builder& insert(size_type index, xtd::byte value) {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      basic_string_builder& insert(size_type index, xtd::decimal value) {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      basic_string_builder& insert(size_type index, double value) {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      basic_string_builder& insert(size_type index, xtd::single value) {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      basic_string_builder& insert(size_type index, xtd::int16 value) {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      basic_string_builder& insert(size_type index, xtd::int32 value) {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      basic_string_builder& insert(size_type index, xtd::int64 value) {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      basic_string_builder& insert(size_type index, xtd::sbyte value) {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      basic_string_builder& insert(size_type index, xtd::uint16 value) {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      basic_string_builder& insert(size_type index, xtd::uint32 value) {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      basic_string_builder& insert(size_type index, xtd::uint64 value) {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      basic_string_builder& insert(size_type index, value_type value) {return insert(index, 1, value);}
      basic_string_builder& insert(size_type index, value_type value, size_type repeat_count) {return insert(index, repeat_count, value);}
      
      basic_string_builder& insert(size_type index, xtd::slong value) {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      basic_string_builder& insert(size_type index, xtd::ulong value) {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      
      template<typename object_t>
      basic_string_builder& insert(size_type index, object_t value) {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      basic_string_builder& insert(size_type index, size_type count, value_type ch) {
        if (index > length()) throw argument_out_of_range_exception {};
        if (length() + count > max_capacity()) throw argument_out_of_range_exception {};
        chars_.insert(index, count, ch);
        return *this;
      }
      basic_string_builder& insert(size_type index, const_pointer s) {return insert(index, basic_string_builder(s));}
      basic_string_builder& insert(size_type index, const_pointer s, size_type count) {return insert(index, basic_string_builder(s, count));}
      basic_string_builder& insert(size_type index, const basic_string_builder& str) {return insert(index, str, 0, str.length());}
      basic_string_builder& insert(size_type index, const basic_string_builder& str, size_type s_index, size_type count) {
        if (length() + count > max_capacity()) throw argument_out_of_range_exception {};
        if (index > length()) throw argument_out_of_range_exception {};
        if (s_index > str.size() || s_index + count > str.length()) throw xtd::argument_out_of_range_exception {};
        chars_.insert(index, str.chars_, s_index, count);
        return *this;
      }
      basic_string_builder& insert(size_type index, const basic_string_builder& str, size_type s_index) {return insert(index, str.chars_, s_index, str.length() - s_index);}
      iterator insert(const_iterator pos, value_type ch) {return insert(pos, 1, ch);}
      iterator insert(const_iterator pos, size_type count, value_type ch ) {
        if (static_cast<size_type>(std::distance(cbegin(), pos)) > length()) throw argument_out_of_range_exception {};
        if (length() + count > max_capacity()) throw argument_out_of_range_exception {};
        return chars_.insert(pos, count, ch);
      }
      template<typename input_iterator_t>
      iterator insert( const_iterator pos, input_iterator_t first, input_iterator_t last) {
        if (static_cast<size_type>(std::distance(cbegin(), pos)) > length()) throw argument_out_of_range_exception {};
        if (length() + std::distance(first, last) > max_capacity()) throw argument_out_of_range_exception {};
        return chars_.insert(pos, first, last);
      }
      iterator insert(const_iterator pos, std::initializer_list<value_type> ilist) {
        if (static_cast<size_type>(std::distance(cbegin(), pos)) > length()) throw argument_out_of_range_exception {};
        return chars_.insert(pos, ilist);
      }
      
      void pop_back() {chars_.pop_back();}
 
      void push_back(value_type ch) {chars_.push_back(ch);}
 
      basic_string_builder& remove(size_type start_index, size_type length) {return erase(start_index, length);}
      
      basic_string_builder& replace(value_type old_char, value_type new_char) noexcept {return replace(old_char, new_char, 0, length());}
      basic_string_builder& replace(value_type old_char, value_type new_char, size_type start_index, size_type count) {return replace(xtd::basic_string<char_t>(1, old_char), xtd::basic_string<char_t>(1, new_char), start_index, count);}
      basic_string_builder& replace(const xtd::basic_string<char_t>& old_value, const xtd::basic_string<char_t>& new_value) noexcept {return replace(old_value, new_value, 0, length());}
      basic_string_builder& replace(const xtd::basic_string<char_t>& old_value, const xtd::basic_string<char_t>& new_value, size_type start_index, size_type count) {
        if (start_index > length() || start_index + count > length()) throw argument_out_of_range_exception {};
        auto old_size = old_value.size();
        auto new_size = new_value.size();
        auto index = xtd::size {0};
        while (true) {
          index = find(old_value, index);
          if (index == npos || index >= start_index + count) break;
          if (index >= start_index) {
            if (old_size == new_size) replace(index, old_size, new_value);
            else {
              erase(index, old_value.size());
              insert(index, new_value);
            }
          }
          index += new_value.size();
        }
        return *this;
      }
      
      basic_string_builder& replace(size_type pos, size_type count, const basic_string_builder& str) {
        if (pos > size() || pos + count > size()) throw argument_out_of_range_exception {};
        chars_.replace(pos, count, str);
        return *this;
      }
      basic_string_builder& replace(const_iterator first, const_iterator last, const basic_string_builder& str) {
        chars_.replace(first, last, str);
        return *this;
      }
      basic_string_builder& replace(size_type pos, size_type count, const basic_string_builder& str, size_type pos2) {
        if (pos > size() || pos + count > size()) throw argument_out_of_range_exception {};
        if (pos2 > str.size()) throw argument_out_of_range_exception {};
        chars_.replace(pos, count, str, pos2);
        return *this;
      }
      basic_string_builder& replace(size_type pos, size_type count, const basic_string_builder& str, size_type pos2, size_type count2) {
        if (pos > size() || pos + count > size()) throw argument_out_of_range_exception {};
        if (pos2 > str.size() || pos2 + count2 > str.size()) throw argument_out_of_range_exception {};
        chars_.replace(pos, count, str, pos2, count2);
        return *this;
      }
      basic_string_builder& replace(size_type pos, size_type count, const_pointer cstr, size_type count2) {
        if (pos > size() || pos + count > size()) throw argument_out_of_range_exception {};
        chars_.replace(pos, count, cstr, count2);
        return *this;
      }
      basic_string_builder& replace(const_iterator first, const_iterator last, const_pointer cstr, size_type count2) {
        chars_.replace(first, last, cstr, count2);
        return *this;
      }
      basic_string_builder& replace(size_type pos, size_type count, const_pointer cstr) {
        chars_.replace(pos, count, cstr);
        return *this;
      }
      basic_string_builder& replace(const_iterator first, const_iterator last, const_pointer cstr) {
        chars_.replace(first, last, cstr);
        return *this;
      }
      basic_string_builder& replace(size_type pos, size_type count, size_type count2, value_type ch) {
        if (pos > size() || pos + count > size()) throw argument_out_of_range_exception {};
        chars_.replace(pos, count, count2, ch);
        return *this;
      }
      basic_string_builder& replace(const_iterator first, const_iterator last, size_type count2, value_type ch) {
        chars_.replace(first, last, count2, ch);
        return *this;
      }
      template<typename input_iterator_t>
      basic_string_builder& replace(const_iterator first, const_iterator last, input_iterator_t first2, input_iterator_t last2) {
        chars_.replace(first, last, first2, last2);
        return *this;
      }
      basic_string_builder& replace(const_iterator first, const_iterator last, std::initializer_list<value_type> ilist) {
        chars_.replace(first, last, ilist);
        return *this;
      }
 
      void reserve(size_type new_cap) {
        if (new_cap > max_capacity_) throw xtd::argument_out_of_range_exception {};
        if (new_cap <= capacity()) return;
        chars_.reserve(new_cap);
      }
      
      void resize(size_type count) {chars_.resize(count);}
      void resize(size_type count, value_type ch) {chars_.resize(count, ch);}
 
      size_type rfind(const basic_string_builder& str) const {return chars_.rfind(str);}
      size_type rfind(const basic_string_builder& 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);}
      
      void shrink_to_fit() {chars_.shrink_to_fit();}
      
      basic_string_builder substr() const {return chars_.substr();}
      basic_string_builder substr(size_type pos) const {
        if (pos > size()) throw argument_out_of_range_exception {};
        return chars_.substr(pos);
      }
      basic_string_builder substr(size_type pos, size_type count) const {
        if (pos > size() || pos + count > size()) throw argument_out_of_range_exception {};
        return chars_.substr(pos, count);
      }
      
      void swap(basic_string_builder& other) noexcept {chars_.swap(other.chars_);}
      
      //xtd::string to_string() const noexcept override {return __xtd_convert_to_string<char>(chars_);}
      xtd::string to_string() const noexcept override {return xtd::string {chars_};}
      
      
 
      
      
      const_reference operator [](xtd::size index) const {
        if (index >= length()) throw xtd::index_out_of_range_exception {};
        return chars_[index];
      }
      reference operator [](xtd::size index) {
        if (index >= length()) throw xtd::index_out_of_range_exception {};
        return chars_[index];
      }
 
      operator const base_type&() const noexcept {return chars_;}
      operator base_type&() noexcept {return chars_;}
 
      basic_string_builder& operator =(const basic_string_builder& str) noexcept {
        chars_ = str.chars_;
        return *this;
      }
      
      basic_string_builder& operator =(basic_string_builder&& str) noexcept {
        chars_ = std::move(str.chars_);
        return *this;
      }
      
      basic_string_builder& operator =(const std::basic_string<value_type>& str) noexcept {
        chars_ = str;
        return *this;
      }
      
      basic_string_builder& operator =(std::basic_string<value_type>&& str) noexcept {
        chars_ = std::move(str);
        return *this;
      }
      
      basic_string_builder& operator =(const xtd::basic_string<value_type>& str) noexcept {
        chars_ = str;
        return *this;
      }
      
      basic_string_builder& operator =(xtd::basic_string<value_type>&& str) noexcept {
        chars_ = std::move(str);
        return *this;
      }
 
      basic_string_builder& operator =(const_pointer str) {
        if (str == null) throw xtd::null_pointer_exception {};
        chars_ = str;
        return *this;
      }
      
      basic_string_builder& operator =(value_type character) {
        chars_ = character;
        return  *this;
      }
      
      basic_string_builder& operator =(const std::initializer_list<value_type>& il) {
        chars_ = il;
        return *this;
      }
      
      basic_string_builder& operator +=(const basic_string_builder& str) {
        chars_ += str.chars_;
        return *this;
      }
      
      basic_string_builder& operator +=(basic_string_builder&& str) {
        chars_ += std::move(str.chars_);
        str.chars_.clear();
        return *this;
      }
      
      basic_string_builder& operator +=(const_pointer str) {
        if (str == null) throw xtd::null_pointer_exception {};
        chars_ += str;
        return *this;
      }
 
      basic_string_builder& operator +=(value_type ch) {
        chars_ += ch;
        return *this;
      }
      
      friend basic_string_builder operator +(const basic_string_builder& lhs, const basic_string_builder& rhs) {
        auto result = lhs;
        result += rhs;
        return result;
      }
      
      friend basic_string_builder operator +(basic_string_builder&& lhs, basic_string_builder&& rhs) {
        auto result = std::move(lhs);
        result += std::move(rhs);
        return result;
      }
      
      friend basic_string_builder operator +(basic_string_builder&& lhs, const basic_string_builder& rhs) {
        auto result = std::move(lhs);
        result += rhs;
        return result;
      }
      
      friend basic_string_builder operator +(const basic_string_builder& lhs, basic_string_builder&& rhs) {
        auto result = lhs;
        result += std::move(rhs);
        return result;
      }
      
      friend basic_string_builder operator +(const basic_string_builder& lhs, const_pointer rhs) {
        auto result = lhs;
        result += rhs;
        return result;
      }
      
      friend basic_string_builder operator +(basic_string_builder&& lhs, const_pointer rhs) {
        auto result = std::move(lhs);
        result += rhs;
        return result;
      }
      
      friend basic_string_builder operator +(const_pointer lhs, const basic_string_builder& rhs) {
        return lhs + rhs.chars_;
      }
      
      friend basic_string_builder operator +(const_pointer lhs, basic_string_builder&& rhs) {
        return lhs + std::move(rhs).chars_;
      }
      
      friend basic_string_builder operator +(basic_string_builder& lhs, value_type rhs) {
        auto result = lhs;
        result += rhs;
        return result;
      }
      
      friend basic_string_builder operator +(basic_string_builder&& lhs, value_type rhs) {
        auto result = std::move(lhs);
        result += rhs;
        return result;
      }
 
      friend basic_string_builder operator +(value_type lhs, const basic_string_builder& rhs) {
        auto result = basic_string_builder(1, lhs);
        result += rhs;
        return result;
      }
      
      friend basic_string_builder operator +(value_type lhs, basic_string_builder&& rhs) {
        auto result = basic_string_builder(1, lhs);
        result += std::move(rhs);
        return result;
      }
      
      //friend std::basic_ostream<char>& operator <<(std::basic_ostream<char>& stream, const basic_string_builder& str) {return stream << str.to_string().chars_;}
      friend std::basic_ostream<char>& operator <<(std::basic_ostream<char>& stream, const basic_string_builder& str) {return stream << xtd::basic_string<char>(str.chars()).chars();}
      friend std::basic_ostream<xtd::wchar>& operator <<(std::basic_ostream<xtd::wchar>& stream, const basic_string_builder& str) {return stream << xtd::basic_string<xtd::wchar>(str.chars()).chars();}
      
      friend std::basic_istream<char>& operator >>(std::basic_istream<char>& stream, basic_string_builder& str) {
        auto s = std::basic_string<char> {};
        stream >> s;
        str = xtd::basic_string<value_type>(s).chars();
        return stream;
      }
      friend std::basic_istream<xtd::wchar>& operator >>(std::basic_istream<xtd::wchar>& stream, basic_string_builder& str) {
        auto s = std::basic_string<xtd::wchar> {};
        stream >> s;
        str = xtd::basic_string<value_type>(s).chars();
        return stream;
      }
      
    private:
      base_type chars_;
      size_type max_capacity_ = chars_.max_size();
    };
  }
}