basic_string_builder.hpp

Go to the documentation of this file.

#pragma once
#include "../basic_string.hpp"
#include "../environment.hpp"
#include "../numeric_literals.hpp"
#include "../range.hpp"
#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::usize capacity) {self_.capacity(capacity);}
      basic_string_builder(xtd::usize capacity, xtd::usize max_capacity) : max_capacity_{max_capacity} {self_.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::usize capacity) : chars_(value.chars()) {self_.capacity(capacity);}
      basic_string_builder(const xtd::basic_string<value_type>& value, xtd::usize start_index, xtd::usize length, xtd::usize capacity) : chars_(value.substring(start_index, length).chars()) {self_.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::usize index) {
        if (index > str.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        chars_ = base_type(str.chars_, index);
      }

      basic_string_builder(const basic_string_builder & str, xtd::usize index, const allocator_type & allocator) {
        if (index > str.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        chars_ = base_type(str.chars_, index, allocator);
      }
      
      basic_string_builder(const basic_string_builder & str, xtd::usize index, xtd::usize count) {
        if (index + count > str.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        chars_ = base_type(str.chars_, index, count);
      }

      basic_string_builder(const basic_string_builder & str, xtd::usize index, xtd::usize count, const allocator_type & allocator) {
        if (index + count > str.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        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::usize count, value_type character) : chars_(count, character) {}
      basic_string_builder(xtd::usize count, value_type character, const allocator_type & allocator) : chars_(count, character, allocator) {}
      
      basic_string_builder(value_type character, xtd::usize count) : chars_(count, character) {}
      basic_string_builder(value_type character, xtd::usize count, const allocator_type & allocator) : chars_(count, character, allocator) {}
      
      basic_string_builder(const_pointer str) {  // Can't be explicit by design.
        if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
        chars_ = base_type(str);
      }

      basic_string_builder(const_pointer str, const allocator_type & allocator) {
        if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
        chars_ = base_type(str, allocator);
      }
      
      basic_string_builder(const_pointer str, xtd::usize count) {
        if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
        chars_ = base_type(str, count);
      }

      basic_string_builder(const_pointer str, xtd::usize count, const allocator_type & allocator) : chars_(allocator) {
        if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
        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) {}
      
      
      [[nodiscard]] auto begin() const -> const_iterator {return chars_.begin();}
      [[nodiscard]] auto begin() -> iterator {return chars_.begin();}
      
      [[nodiscard]] auto c_str() const noexcept -> const_pointer {return chars_.c_str();}
      
      [[nodiscard]] auto capacity() const noexcept -> size_type {return chars_.capacity();}
      auto capacity(size_type value) -> basic_string_builder& {
        if (value > max_capacity_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        chars_.reserve(value);
        return self_;
      }
      
      [[nodiscard]] auto cbegin() const -> const_iterator {return chars_.cbegin();}
      
      [[nodiscard]] auto chars() const noexcept -> const base_type& {return chars_;}
      
      [[nodiscard]] auto chars() noexcept -> base_type& {return chars_;}
      
      [[nodiscard]] auto cend() const -> const_iterator {return chars_.cend();}
      
      [[nodiscard]] auto data() const noexcept -> const_pointer {return chars_.data();}
      [[nodiscard]] auto data() noexcept -> pointer {return chars_.data();}
      
      [[nodiscard]] auto empty() const noexcept -> bool {return chars_.empty();}
      
      [[nodiscard]] auto end() const -> const_iterator {return chars_.end();}
      [[nodiscard]] auto end() -> iterator {return chars_.end();}
      
      [[nodiscard]] auto length() const noexcept -> size_type {return chars_.size();}
      auto length(size_type value) noexcept -> basic_string_builder& {
        if (value != length()) chars_.resize(value);
        return self_;
      }
      
      [[nodiscard]] auto max_capacity() const noexcept -> size_type {return max_capacity_;}
      
      [[nodiscard]] auto size() const noexcept -> size_type {return length();}
      
      
      auto append(const xtd::basic_string<char_t>& value) -> basic_string_builder& {return append(basic_string_builder {value});}
      auto append(const xtd::basic_string<char_t>& value, size_type start_index, size_type count) -> basic_string_builder& {return append(basic_string_builder {value, start_index, count});}
      auto append(xtd::boolean value) -> basic_string_builder& {return append_format("{}", value);}
      auto append(xtd::byte value) -> basic_string_builder& {return append_format("{}", value);}
      auto append(xtd::decimal value) -> basic_string_builder& {return append_format("{}", value);}
      auto append(double value) -> basic_string_builder& {return append_format("{}", value);}
      auto append(xtd::single value) -> basic_string_builder& {return append_format("{}", value);}
      auto append(xtd::int16 value) -> basic_string_builder& {return append_format("{}", value);}
      auto append(xtd::int32 value) -> basic_string_builder& {return append_format("{}", value);}
      auto append(xtd::int64 value) -> basic_string_builder& {return append_format("{}", value);}
      auto append(xtd::sbyte value) -> basic_string_builder& {return append_format("{}", value);}
      auto append(xtd::uint16 value) -> basic_string_builder& {return append_format("{}", value);}
      auto append(xtd::uint32 value) -> basic_string_builder& {return append_format("{}", value);}
      auto append(xtd::uint64 value) -> basic_string_builder& {return append_format("{}", value);}
      auto append(value_type value) -> basic_string_builder& {return append(1_z, value);}
      auto append(value_type value, size_type repeat_count) -> basic_string_builder& {return append(repeat_count, value);}
      
      auto append(xtd::slong value) -> basic_string_builder& {return append_format("{}", value);}
      auto append(xtd::ulong value) -> basic_string_builder& {return append_format("{}", value);}
      
      template<typename object_t>
      auto append(object_t value) -> basic_string_builder& {return append_format("{}", value);}
      auto append(size_type count, value_type ch) -> basic_string_builder& {return append(basic_string_builder(count, ch));}
      auto append(const basic_string_builder & str) -> basic_string_builder& {return append(str, 0, str.length());}
      auto append(const basic_string_builder & str, size_type pos) -> basic_string_builder& {return append(str, pos, str.length() - pos);}
      auto append(const basic_string_builder & str, size_type pos, size_type count) -> basic_string_builder& {
        if (length() + count > max_capacity()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        if (pos > str.length() || pos + count > str.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        chars_.append(str.chars_, pos, count);
        return self_;
      }

      auto append(const_pointer s, size_type count) -> basic_string_builder& {return append(basic_string_builder {s, count});}
      auto append(const_pointer s) -> basic_string_builder& {return append(basic_string_builder {s});}
      template<typename input_iterator_t>
      auto append(input_iterator_t first, input_iterator_t last) -> basic_string_builder& {
        if (length() + std::distance(first, last) > max_capacity()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        return append(basic_string_builder {first, last});
      }

      auto append(std::initializer_list<value_type> ilist) -> basic_string_builder& {return append(basic_string_builder {ilist});}
      
      template<typename ...args_t>
      auto append_format(const xtd::basic_string<char_t>& format, args_t&& ... args) -> basic_string_builder& {return append(xtd::basic_string<char_t>::format(format, std::forward<args_t>(args)...));}
      
      template<typename collection_t>
      auto append_join(const xtd::basic_string<char_t>& separator, const collection_t& values) -> basic_string_builder& {return append(xtd::basic_string<char_t>::join(separator, values));}
      template<typename collection_t>
      auto append_join(value_type separator, const collection_t& values) -> basic_string_builder& {return append(xtd::basic_string<char_t>::join(xtd::basic_string<char_t>(separator, 1), values));}
      
      template<typename value_t>
      auto append_join(const xtd::basic_string<char_t>& separator, const std::initializer_list<value_t>& values) -> basic_string_builder& {return append_join(separator, xtd::array<value_t>(values));}
      template<typename value_t>
      auto append_join(value_type separator, const std::initializer_list<value_t>& values) -> basic_string_builder& {return append_join(separator, xtd::array<value_t>(values));}
      
      auto append_line() -> basic_string_builder& {return append(xtd::basic_string<char_t> {xtd::environment::new_line()});}
      auto append_line(const xtd::basic_string<char_t>& value) -> basic_string_builder& {return append(value).append_line();}
      
      auto clear() -> basic_string_builder& {
        chars_.clear();
        return self_;
      }
      
      auto copy_to(xtd::usize source_index, xtd::array<value_type>& destination, xtd::usize destination_index, xtd::usize destination_count) const -> void {
        if (source_index > length() || source_index + destination_count > length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        if (destination_index >= destination.length() || destination_index + destination_count > destination.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        chars_.copy(destination.data() + destination_index, destination_count, source_index);
      }
      
      [[nodiscard]] auto equals(const object & obj) const noexcept -> bool override {return dynamic_cast<const basic_string_builder*>(&obj) && equals(static_cast<const basic_string_builder&>(obj));}
      [[nodiscard]] auto equals(const basic_string_builder & value) const noexcept -> bool override {return chars_ == value.chars_;}
      
      auto ensure_capacity(size_type capacity) -> size_type {
        if (self_.capacity() < capacity) self_.capacity(capacity);
        return self_.capacity();
      }
      
      [[nodiscard]] auto get_base_type() const noexcept -> const base_type& {return chars_;}
      
      [[nodiscard]] auto get_hash_code() const noexcept -> xtd::usize override {return xtd::hash_code::combine(chars_);}
      
      auto insert(size_type index, const xtd::basic_string<char_t>& value) -> basic_string_builder& {return insert(index, basic_string_builder {value}, 0, value.length());}
      auto insert(size_type index, const xtd::basic_string<char_t>& value, size_type count) -> basic_string_builder& {return insert(index, basic_string_builder {value}, 0, count);}
      auto insert(size_type index, xtd::boolean value) -> basic_string_builder& {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      auto insert(size_type index, xtd::byte value) -> basic_string_builder& {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      auto insert(size_type index, xtd::decimal value) -> basic_string_builder& {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      auto insert(size_type index, double value) -> basic_string_builder& {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      auto insert(size_type index, xtd::single value) -> basic_string_builder& {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      auto insert(size_type index, xtd::int16 value) -> basic_string_builder& {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      auto insert(size_type index, xtd::int32 value) -> basic_string_builder& {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      auto insert(size_type index, xtd::int64 value) -> basic_string_builder& {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      auto insert(size_type index, xtd::sbyte value) -> basic_string_builder& {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      auto insert(size_type index, xtd::uint16 value) -> basic_string_builder& {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      auto insert(size_type index, xtd::uint32 value) -> basic_string_builder& {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      auto insert(size_type index, xtd::uint64 value) -> basic_string_builder& {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      auto insert(size_type index, value_type value) -> basic_string_builder& {return insert(index, 1, value);}
      auto insert(size_type index, value_type value, size_type repeat_count) -> basic_string_builder& {return insert(index, repeat_count, value);}
      
      auto insert(size_type index, xtd::slong value) -> basic_string_builder& {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      auto insert(size_type index, xtd::ulong value) -> basic_string_builder& {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      
      template<typename object_t>
      auto insert(size_type index, object_t value) -> basic_string_builder& {return insert(index, xtd::basic_string<char_t>::format("{}", value));}
      auto insert(size_type index, size_type count, value_type ch) -> basic_string_builder& {
        if (index > length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        if (length() + count > max_capacity()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        chars_.insert(index, count, ch);
        return self_;
      }

      auto insert(size_type index, const_pointer s) -> basic_string_builder& {return insert(index, basic_string_builder(s));}
      auto insert(size_type index, const_pointer s, size_type count) -> basic_string_builder& {return insert(index, basic_string_builder(s, count));}
      auto insert(size_type index, const basic_string_builder & str) -> basic_string_builder& {return insert(index, str, 0, str.length());}
      auto insert(size_type index, const basic_string_builder & str, size_type s_index, size_type count) -> basic_string_builder& {
        if (length() + count > max_capacity()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        if (index > length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        if (s_index > str.length() || s_index + count > str.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        chars_.insert(index, str.chars_, s_index, count);
        return self_;
      }
      auto insert(size_type index, const basic_string_builder & str, size_type s_index) -> basic_string_builder& {return insert(index, str.chars_, s_index, str.length() - s_index);}
      
      auto remove(size_type start_index, size_type length) -> basic_string_builder& {return erase(start_index, length);}
      
      auto replace(value_type old_char, value_type new_char) noexcept -> basic_string_builder& {return replace(old_char, new_char, 0, length());}
      auto replace(value_type old_char, value_type new_char, size_type start_index, size_type count) -> basic_string_builder& {return replace(xtd::basic_string<char_t>(old_char, 1), xtd::basic_string<char_t>(new_char, 1), start_index, count);}
      auto replace(const xtd::basic_string<char_t>& old_value, const xtd::basic_string<char_t>& new_value) noexcept -> basic_string_builder& {return replace(old_value, new_value, 0, length());}
      auto replace(const xtd::basic_string<char_t>& old_value, const xtd::basic_string<char_t>& new_value, size_type start_index, size_type count) -> basic_string_builder& {
        if (start_index > length() || start_index + count > length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        auto old_size = old_value.length();
        auto new_size = new_value.length();
        auto index = xtd::usize {0};
        while (true) {
          index = chars_.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 {
              chars_.erase(index, old_value.length());
              insert(index, new_value);
            }
          }
          index += new_value.length();
        }
        return self_;
      }
      
      auto replace(size_type pos, size_type count, const basic_string_builder & str) -> basic_string_builder& {
        if (pos > size() || pos + count > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        chars_.replace(pos, count, str);
        return self_;
      }

      auto replace(const_iterator first, const_iterator last, const basic_string_builder & str) -> basic_string_builder& {
        chars_.replace(first, last, str);
        return self_;
      }
      auto replace(size_type pos, size_type count, const basic_string_builder & str, size_type pos2) -> basic_string_builder& {
        if (pos > size() || pos + count > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        if (pos2 > str.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        chars_.replace(pos, count, str, pos2);
        return self_;
      }

      auto replace(size_type pos, size_type count, const basic_string_builder & str, size_type pos2, size_type count2) -> basic_string_builder& {
        if (pos > size() || pos + count > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        if (pos2 > str.length() || pos2 + count2 > str.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        chars_.replace(pos, count, str, pos2, count2);
        return self_;
      }

      auto replace(size_type pos, size_type count, const_pointer cstr, size_type count2) -> basic_string_builder& {
        if (pos > size() || pos + count > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        chars_.replace(pos, count, cstr, count2);
        return self_;
      }

      auto replace(const_iterator first, const_iterator last, const_pointer cstr, size_type count2) -> basic_string_builder& {
        chars_.replace(first, last, cstr, count2);
        return self_;
      }
      auto replace(size_type pos, size_type count, const_pointer cstr) -> basic_string_builder& {
        chars_.replace(pos, count, cstr);
        return self_;
      }

      auto replace(const_iterator first, const_iterator last, const_pointer cstr) -> basic_string_builder& {
        chars_.replace(first, last, cstr);
        return self_;
      }
      auto replace(size_type pos, size_type count, size_type count2, value_type ch) -> basic_string_builder& {
        if (pos > size() || pos + count > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        chars_.replace(pos, count, count2, ch);
        return self_;
      }

      auto replace(const_iterator first, const_iterator last, size_type count2, value_type ch) -> basic_string_builder& {
        chars_.replace(first, last, count2, ch);
        return self_;
      }
      template<typename input_iterator_t>
      auto replace(const_iterator first, const_iterator last, input_iterator_t first2, input_iterator_t last2) -> basic_string_builder& {
        chars_.replace(first, last, first2, last2);
        return self_;
      }
      auto replace(const_iterator first, const_iterator last, std::initializer_list<value_type> ilist) -> basic_string_builder& {
        chars_.replace(first, last, ilist);
        return self_;
      }

      //xtd::string to_string() const noexcept override {return __xtd_convert_to_string<char>(chars_);}
      [[nodiscard]] auto to_string() const noexcept -> xtd::string override {return xtd::string {chars_};}
      
      
      
      
      
      auto operator [](xtd::usize index) const -> const_reference {
        if (index >= length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
        return chars_[index];
      }

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

      auto operator [](const xtd::index& index) const -> const_reference {return operator [](index.get_offset(length()));}
      auto operator [](const xtd::index& index) -> reference {return operator [](index.get_offset(length()));}
      auto operator [](const xtd::range& range) const -> xtd::basic_read_only_string_view<char_t> {
        //return xtd::basic_read_only_string_view<type_t>(self(), range);
        auto [start, length] = range.get_offset_and_length(size());
        return xtd::basic_read_only_string_view<char_t> {chars_.begin() + start, chars_.begin() + start + length};
      }

      auto operator [](const xtd::range& range) -> xtd::basic_string_view<char_t> {
        //return xtd::basic_string_view<type_t>(self(), range);
        auto [start, length] = range.get_offset_and_length(size());
        return xtd::basic_string_view<char_t> {chars_.begin() + start, chars_.begin() + start + length};
      }

      auto operator ()(xtd::usize index) const -> const_reference {return operator[](index);}
      auto operator ()(xtd::usize index) -> reference {return operator[](index);}
      auto operator ()(const xtd::index& index) const -> const_reference {return operator[](index);}
      auto operator ()(const xtd::index& index) -> reference {return operator[](index);}
      auto operator ()(const xtd::range& range) const -> xtd::basic_read_only_string_view<char_t> {return operator [](range);}
      auto operator ()(const xtd::range& range) -> xtd::basic_string_view<char_t> {return operator [](range);}

      operator const base_type& () const noexcept {return chars_;}
      operator base_type& () noexcept {return chars_;}
      
      auto operator =(const basic_string_builder & str) noexcept -> basic_string_builder& {
        chars_ = str.chars_;
        return self_;
      }
      
      auto operator =(basic_string_builder&& str) noexcept -> basic_string_builder& {
        chars_ = std::move(str.chars_);
        return self_;
      }
      
      auto operator =(const std::basic_string<value_type>& str) noexcept -> basic_string_builder& {
        chars_ = str;
        return self_;
      }
      
      auto operator =(std::basic_string<value_type>&& str) noexcept -> basic_string_builder& {
        chars_ = std::move(str);
        return self_;
      }
      
      auto operator =(const xtd::basic_string<value_type>& str) noexcept -> basic_string_builder& {
        chars_ = str;
        return self_;
      }
      
      auto operator =(xtd::basic_string<value_type>&& str) noexcept -> basic_string_builder& {
        chars_ = std::move(str);
        return self_;
      }
      
      auto operator =(const_pointer str) -> basic_string_builder& {
        if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
        chars_ = str;
        return self_;
      }
      
      auto operator =(value_type character) -> basic_string_builder& {
        chars_ = character;
        return  self_;
      }
      
      auto operator =(const std::initializer_list<value_type>& il) -> basic_string_builder& {
        chars_ = il;
        return self_;
      }
      
      auto operator +=(const basic_string_builder & str) -> basic_string_builder& {
        chars_ += str.chars_;
        return self_;
      }
      
      auto operator +=(basic_string_builder&& str) -> basic_string_builder& {
        chars_ += std::move(str.chars_);
        str.chars_.clear();
        return self_;
      }
      
      auto operator +=(const_pointer str) -> basic_string_builder& {
        if (str == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
        chars_ += str;
        return self_;
      }
      
      auto operator +=(value_type ch) -> basic_string_builder& {
        chars_ += ch;
        return self_;
      }
      
      friend auto operator +(const basic_string_builder & lhs, const basic_string_builder & rhs) -> basic_string_builder {
        auto result = lhs;
        result += rhs;
        return result;
      }
      
      friend auto operator +(basic_string_builder&& lhs, basic_string_builder&& rhs) -> basic_string_builder {
        auto result = std::move(lhs);
        result += std::move(rhs);
        return result;
      }
      
      friend auto operator +(basic_string_builder&& lhs, const basic_string_builder & rhs) -> basic_string_builder {
        auto result = std::move(lhs);
        result += rhs;
        return result;
      }
      
      friend auto operator +(const basic_string_builder & lhs, basic_string_builder&& rhs) -> basic_string_builder {
        auto result = lhs;
        result += std::move(rhs);
        return result;
      }
      
      friend auto operator +(const basic_string_builder & lhs, const_pointer rhs) -> basic_string_builder {
        auto result = lhs;
        result += rhs;
        return result;
      }
      
      friend auto operator +(basic_string_builder&& lhs, const_pointer rhs) -> basic_string_builder {
        auto result = std::move(lhs);
        result += rhs;
        return result;
      }
      
      friend auto operator +(const_pointer lhs, const basic_string_builder & rhs) -> basic_string_builder {
        return lhs + rhs.chars_;
      }
      
      friend auto operator +(const_pointer lhs, basic_string_builder&& rhs) -> basic_string_builder {
        return lhs + std::move(rhs).chars_;
      }
      
      friend auto operator +(basic_string_builder & lhs, value_type rhs) -> basic_string_builder {
        auto result = lhs;
        result += rhs;
        return result;
      }
      
      friend auto operator +(basic_string_builder&& lhs, value_type rhs) -> basic_string_builder {
        auto result = std::move(lhs);
        result += rhs;
        return result;
      }
      
      friend auto operator +(value_type lhs, const basic_string_builder & rhs) -> basic_string_builder {
        auto result = basic_string_builder(1, lhs);
        result += rhs;
        return result;
      }
      
      friend auto operator +(value_type lhs, basic_string_builder&& rhs) -> basic_string_builder {
        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 auto operator <<(std::ostream& stream, const basic_string_builder & str) -> std::ostream& {return stream << xtd::basic_string<char>(str.chars()).chars();}
      friend auto operator <<(std::wostream& stream, const basic_string_builder & str) -> std::wostream& {return stream << xtd::basic_string<xtd::wchar>(str.chars()).chars();}
      
      friend auto operator >>(std::istream& stream, basic_string_builder & str) -> std::istream& {
        auto s = std::string {};
        stream >> s;
        str = xtd::basic_string<value_type>(s).chars();
        return stream;
      }

      friend auto operator >>(std::wistream& stream, basic_string_builder & str) -> std::wistream& {
        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();
    };
  }
}