xtd::text::basic_string_builder< char_t, traits_t, allocator_t > Class Template Reference

Inheritance diagram for xtd::text::basic_string_builder< char_t, traits_t, allocator_t >:

Definition

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>
class xtd::text::basic_string_builder< char_t, traits_t, allocator_t >

Represents a mutable string of characters. This class cannot be inherited.

Namespace

xtd::text

Library

xtd.core

Remarks

xtd::text::basic_string_builder class represents a string-like object whose value is a mutable sequence of characters.

xtd::text::basic_string_builder implements std::basic_string<char> and therefore offers the full API of std::basic_string.

Several aliases for common character types are provided:

Type	Definition
xtd::text::string_builder	xtd::text::basic_string_builder <char>
xtd::text::u16string_builder	xtd::text::basic_string_builder <xtd::char16>
xtd::text::u32string_builder	xtd::text::basic_string_builder <xtd::char32>
xtd::text::u8string_builder	xtd::text::basic_string_builder <xtd::char8>
xtd::text::wstring_builder	xtd::text::basic_string_builder <xtd::wchar>

Public Methods
Appends a copy of the specified string to this instance. / / / / Parameters value The string to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The xtd::text::basic_string_builder::append (const xtd::basic_string&) method modifies the existing instance of this class; it does not return a new class instance. Because of this, you can call a method or property on the existing reference and you do not have to assign the return value to a xtd::text::basic_string_builder object, as the following example illustrates. / / auto flag = false; / auto sb = xtd::text::string_builder {}; / sb.append("The value of the flag is ").append(flag).append("."); / console::write_line(sb.to_string()); / / // The example displays the following output: / // / // The value of the flag is `false`. / / If value is empty, no changes are made. / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(const xtd::basic_string<char_t>& value) {return append(basic_string_builder {value});} / Appends a copy of a specified substring to this instance. / Parameters value The string that contains the substring to append. / start_index The starting position of the substring within value. / count The number of characters in value to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. -or- `start_index` + `count` is greater than the length of `value`. / Remarks This method appends the specified range of characters in value to the current instance. If value is empty and start_index and count are both zero, no changes are made. / The xtd::text::basic_string_builder::append (const xtd::basic_string&, size_type, size_type) method modifies the existing instance of this class; it does not return a new class instance. Because of this, you can call a method or property on the existing reference and you do not have to assign the return value to a xtd::text::basic_string_builder object, as the following example illustrates. / / auto str = "First;George Washington;1789;1797"_s; / auto index = 0_z; / auto sb = xtd::text::string_builder {}; / auto length = str.index_of(';', index); / sb.append(str, index, length).append(" President of the United States: "); / index += length + 1; / length = str.index_of(';', index) - index; / sb.append(str, index, length).append(", from "); / index += length + 1; / length = str.index_of(';', index) - index; / sb.append(str, index, length).append(" to "); / index += length + 1; / sb.append(str, index, str.length() - index); / console::write_line(sb); / / // The example displays the following output: / // / // First President of the United States: George Washington, from 1789 to 1797 / / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. 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});} / Appends the string representation of a specified boolean value to this instance. / Parameters value The boolean value to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The xtd::text::basic_string_builder::append (xtd::boolean) method modifies the existing instance of this class; it does not return a new class instance. Because of this, you can call a method or property on the existing reference and you do not have to assign the return value to a xtd::text::basic_string_builder object, as the following example illustrates. / / auto flag = false; / auto sb = xtd::text::string_builder {}; / sb.append("The value of the flag is ").append(flag).append("."); / console::write_line(sb.to_string()); / / // The example displays the following output: / // / // The value of the flag is `false`. / / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(xtd::boolean value) {return append_format("{}", value);} / Appends the string representation of a specified 8-bit unsigned value to this instance. / Parameters value The 8-bit unsigned value to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The xtd::text::basic_string_builder::append (xtd::byte) method modifies the existing instance of this class; it does not return a new class instance. Because of this, you can call a method or property on the existing reference and you do not have to assign the return value to a xtd::text::basic_string_builder object, as the following example illustrates. / / auto bytes = array<byte> {16, 132, 27, 253}; / auto sb = xtd::text::string_builder {}; / for (auto value : bytes) / sb.append(value).append(" "); / console::write_line("The byte array: {0}", sb.to_string()); / / // The example displays the following output: / // / // The byte array: 16 132 27 253 / / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(xtd::byte value) {return append_format("{}", value);} / Appends the string representation of a specified decimal value to this instance. / Parameters value The decimal value to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The xtd::text::basic_string_builder::append (xtd::decimal) method modifies the existing instance of this class; it does not return a new class instance. Because of this, you can call a method or property on the existing reference and you do not have to assign the return value to a xtd::text::basic_string_builder object, as the following example illustrates. / / auto value = 1346.19l; / auto sb = xtd::text::string_builder {}; / sb.append('*', 5).append(value).append('*', 5); / console::write_line(sb); / / // The example displays the following output: / // / // *****1346.19***** / / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(xtd::decimal value) {return append_format("{}", value);} / Appends the string representation of a specified double value to this instance. / Parameters value The double value to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The xtd::text::basic_string_builder::append (double) method modifies the existing instance of this class; it does not return a new class instance. Because of this, you can call a method or property on the existing reference and you do not have to assign the return value to a xtd::text::basic_string_builder object, as the following example illustrates. / / auto value = 1346.19; / auto sb = xtd::text::string_builder {}; / sb.append('*', 5).append(value).append('*', 5); / console::write_line(sb); / / // The example displays the following output: / // / // *****1346.19***** / / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(double value) {return append_format("{}", value);} / Appends the string representation of a specified single value to this instance. / Parameters value The single value to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The xtd::text::basic_string_builder::append (xtd::single) method modifies the existing instance of this class; it does not return a new class instance. Because of this, you can call a method or property on the existing reference and you do not have to assign the return value to a xtd::text::basic_string_builder object, as the following example illustrates. / / auto value = 1346.19f; / auto sb = xtd::text::string_builder {}; / sb.append('*', 5).append(value).append('*', 5); / console::write_line(sb); / / // The example displays the following output: / // / // *****1346.19***** / / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(xtd::single value) {return append_format("{}", value);} / Appends the string representation of a specified 16-bit signed integer value to this instance. / Parameters value The 16-bit signed value to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The xtd::text::basic_string_builder::append (xtd::int16) method modifies the existing instance of this class; it does not return a new class instance. Because of this, you can call a method or property on the existing reference and you do not have to assign the return value to a xtd::text::basic_string_builder object, as the following example illustrates. / / auto value = 1346_s16; / auto sb = xtd::text::string_builder {}; / sb.append('*', 5).append(value).append('*', 5); / console::write_line(sb); / / // The example displays the following output: / // / // *****1346***** / / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(xtd::int16 value) {return append_format("{}", value);} / Appends the string representation of a specified 32-bit signed integer value to this instance. / Parameters value The 32-bit signed value to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The xtd::text::basic_string_builder::append (xtd::int32) method modifies the existing instance of this class; it does not return a new class instance. Because of this, you can call a method or property on the existing reference and you do not have to assign the return value to a xtd::text::basic_string_builder object, as the following example illustrates. / / auto value = 1346; / auto sb = xtd::text::string_builder {}; / sb.append('*', 5).append(value).append('*', 5); / console::write_line(sb); / / // The example displays the following output: / // / // *****1346***** / / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(xtd::int32 value) {return append_format("{}", value);} / Appends the string representation of a specified 64-bit signed integer value to this instance. / Parameters value The 64-bit signed value to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The xtd::text::basic_string_builder::append (xtd::int64) method modifies the existing instance of this class; it does not return a new class instance. Because of this, you can call a method or property on the existing reference and you do not have to assign the return value to a xtd::text::basic_string_builder object, as the following example illustrates. / / auto value = 1346_s64; / auto sb = xtd::text::string_builder {}; / sb.append('*', 5).append(value).append('*', 5); / console::write_line(sb); / / // The example displays the following output: / // / // *****1346***** / / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(xtd::int64 value) {return append_format("{}", value);} / Appends the string representation of a specified 8-bit signed integer value to this instance. / Parameters value The 8-bit signed integer value to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The xtd::text::basic_string_builder::append (xtd::sbyte) method modifies the existing instance of this class; it does not return a new class instance. Because of this, you can call a method or property on the existing reference and you do not have to assign the return value to a xtd::text::basic_string_builder object, as the following example illustrates. / / auto bytes = array<sbyte> {16, 132, 27, 253}; / auto sb = xtd::text::string_builder {}; / for (auto value : bytes) / sb.append(value).append(" "); / console::write_line("The byte array: {0}", sb.to_string()); / / // The example displays the following output: / // / // The byte array: 16 132 27 253 / / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(xtd::sbyte value) {return append_format("{}", value);} / Appends the string representation of a specified 16-bit unsigned integer value to this instance. / Parameters value The 16-bit unsigned value to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The xtd::text::basic_string_builder::append (xtd::uint16) method modifies the existing instance of this class; it does not return a new class instance. Because of this, you can call a method or property on the existing reference and you do not have to assign the return value to a xtd::text::basic_string_builder object, as the following example illustrates. / / auto value = 1346_u16; / auto sb = xtd::text::string_builder {}; / sb.append('*', 5).append(value).append('*', 5); / console::write_line(sb); / / // The example displays the following output: / // / // *****1346***** / / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(xtd::uint16 value) {return append_format("{}", value);} / Appends the string representation of a specified 32-bit unsigned integer value to this instance. / Parameters value The 32-bit unsigned value to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The xtd::text::basic_string_builder::append (xtd::uint32) method modifies the existing instance of this class; it does not return a new class instance. Because of this, you can call a method or property on the existing reference and you do not have to assign the return value to a xtd::text::basic_string_builder object, as the following example illustrates. / / auto value = 1346_u32; / auto sb = xtd::text::string_builder {}; / sb.append('*', 5).append(value).append('*', 5); / console::write_line(sb); / / // The example displays the following output: / // / // *****1346***** / / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(xtd::uint32 value) {return append_format("{}", value);} / Appends the string representation of a specified 64-bit unsigned integer value to this instance. / Parameters value The 64-bit unsigned value to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The xtd::text::basic_string_builder::append (xtd::uint64) method modifies the existing instance of this class; it does not return a new class instance. Because of this, you can call a method or property on the existing reference and you do not have to assign the return value to a xtd::text::basic_string_builder object, as the following example illustrates. / / auto value = 1346_u64; / auto sb = xtd::text::string_builder {}; / sb.append('*', 5).append(value).append('*', 5); / console::write_line(sb); / / // The example displays the following output: / // / // *****1346***** / / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(xtd::uint64 value) {return append_format("{}", value);} / Appends the string representation of a specified xtd::text::basic_string_builder::value_type value to this instance. / Parameters value The xtd::text::basic_string_builder::value_type value to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The xtd::text::basic_string_builder::append (xtd::text::basic_string_builder::value_type) method modifies the existing instance of this class; it does not return a new class instance. Because of this, you can call a method or property on the existing reference and you do not have to assign the return value to a xtd::text::basic_string_builder object, as the following example illustrates. / / auto str = "Characters in a string."; / auto sb = xtd::text::string_builder {}; / for (auto ch : str) / sb.append(" '").append(ch).append("' "); / / console::write_line("Characters in the string:"); / console::write_line(" {}", sb); / / // The example displays the following output: / // / // Characters in the string: / // 'C' 'h' 'a' 'r' 'a' 'c' 't' 'e' 'r' 's' ' ' 'i' 'n' ' ' 'a' ' ' 's' 't' 'r' 'i' 'n' 'g' '.' / / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(value_type value) {return append(1_z, value);} / Appends a specified number of copies of the string representation of a Unicode character to this instance. / Parameters value The character to append. / repeat_count The number of times to append value. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The xtd::text::basic_string_builder::append (xtd::text::basic_string_builder::value_type, xtd::text::basic_string_builder::size_type) method modifies the existing instance of this class; it does not return a new class instance. Because of this, you can call a method or property on the existing reference and you do not have to assign the return value to a xtd::text::basic_string_builder object, as the following example illustrates. / / auto value = 1346.19; / auto sb = xtd::text::string_builder {}; / sb.append('*', 5).append(value).append('*', 5); / console::write_line(sb); / / // The example displays the following output: / // / // *****1346.19***** / / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(value_type value, size_type repeat_count) {return append(repeat_count, value);} / / Appends the string representation of a specified object to this instance. / Template Parameters object_t The type of object to append. / Parameters value The object to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The xtd::text::basic_string_builder::append (object_t) method modifies the existing instance of this class; it does not return a new class instance. Because of this, you can call a method or property on the existing reference and you do not have to assign the return value to a xtd::text::basic_string_builder object, as the following example illustrates. It defines a dog class, creates a dog object, and makes three calls to the xtd::text::basic_string_builder::append method to create a string that contains the dog's name and breed. / #include <xtd/text/string_builder> #include <xtd/console> #include <xtd/istringable> using namespace xtd; class dog : public istringable { private: string dog_breed; string dog_name; public: dog(const string& name, const string& breed) : dog_breed(breed), dog_name(name) {} const string& breed() const noexcept {return dog_breed;} const string& name() const noexcept {return dog_name;} string to_string() const noexcept override {return dog_name;} }; auto main() -> int { auto dog1 = dog {"Mocka", "American Shepherd"}; auto sb = xtd::text::string_builder {}; sb.append(dog1).append(", breed: ").append(dog1.breed()); console::write_line(sb); } // This code produces the following output : // // Mocka, breed: American Shepherd / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. template<class object_t> basic_string_builder& append(object_t value) {return append_format("{}", value);} / Appends additional characters to the string. / Parameters count The number of characters to append. / ch The character value to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks Appends count copies of character ch. / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(size_type count, value_type ch) {return append(basic_string_builder(count, ch));} / Appends additional characters to the string. / Parameters str The string to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks Appends string str. / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(const basic_string_builder& str) {return append(str, 0, str.length());} / Appends additional characters to the string. / Parameters str The string to append. / pos The index of the first character to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks Appends a substring [pos, pos + count) of str. / If the requested substring lasts past the end of the string, or if count == npos, the appended substring is [pos, size()). / If pos > str.size(), std::out_of_range is thrown. / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(const basic_string_builder& str, size_type pos) {return append(str, pos, str.length() - pos);} / Appends additional characters to the string. / Parameters str The string to append. / pos The index of the first character to append. / count The number of characters to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks Appends a substring [pos, pos + count) of str. / If the requested substring lasts past the end of the string, or if count == npos, the appended substring is [pos, size()). / If pos > str.size(), std::out_of_range is thrown. / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(const basic_string_builder& str, size_type pos, size_type count) { if (length() + count > max_capacity()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range); if (pos > str.size() || pos + count > str.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);; chars_.append(str.chars_, pos, count); return *this; } / Appends additional characters to the string. / Parameters s The pointer to the character string to append. / count The number of characters to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks Appends characters in the range [s, s + count). This range can contain null characters. / If [s, s + count) is not a valid range, the behavior is undefined. / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(const_pointer s, size_type count) {return append(basic_string_builder {s, count});} / Appends additional characters to the string. / Parameters s The pointer to the character string to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks Appends the null-terminated character string pointed to by s, as if by append(s, traits_t::length(s)). / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(const_pointer s) {return append(basic_string_builder {s});} / Appends additional characters to the string. / Parameters first The first iterator of the range of characters to append. / last The last iterator of the range of characters to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks Appends characters in the range [first, last). / This overload only participates in overload resolution if input_iterator_t qualifies as a LegacyInputIterator. / The capacity of this instance is adjusted as needed. 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()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range); return append(basic_string_builder {first, last}); } / Appends additional characters to the string. / Parameters ilist The initializer list with the characters to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks Appends characters from the initializer list ilist. / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append(std::initializer_list<value_type> ilist) {return append(basic_string_builder {ilist});} / Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Each format item is replaced by the string representation of a corresponding argument in a parameters. / Template Parameters ...args_t Types of the values to format. / Parameters format A composite format string. / args Arguments to format. / Returns A reference to this instance with format appended. Each format item in format is replaced by the string representation of the corresponding object argument. / Exceptions xtd::format_exception `format` is invalid. / Remarks This method uses the composite formatting feature of the xtd framework to convert the value of an object to its text representation and embed that representation in the current xtd::text::basic_string_builder object. / The format parameter consists of optional zero or more runs of text intermixed with zero or more indexed placeholders, called format items, that correspond to objects in the parameter list of this method. The formatting process replaces each format item with the string representation of the corresponding object. / The syntax of a format item is as follows: / {[index][,length][:format_string]} / Elements in square brackets are optional. The following table describes each element. / | Element | Description | / | -----------— | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------— | / | index | The optional zero-based position in the parameter list of the object to be formatted. If there is no parameter in the index position, a xtd::format_exception is thrown. | / | length | The minimum number of characters in the string representation of the parameter. If positive, the parameter is right-aligned; if negative, it is left-aligned. | / | :format_string | A standard or custom format string that is supported by the parameter. | / The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. template<class ...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)...));} / Concatenates and appends the members of a collection, using the specified separator between each member. / Parameters separator The string to use as a separator. separator is included in the concatenated and appended strings only if values has more than one element. / values A collection that contains the objects to concatenate and append to the current instance of the string builder. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. template<class 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));} / Concatenates and appends the members of a collection, using the specified xtd::basic_string_builder::value_type separator between each member. / Parameters separator The xtd::basic_string_builder::value_type to use as a separator. separator is included in the concatenated and appended strings only if values has more than one element. / values A collection that contains the objects to concatenate and append to the current instance of the string builder. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. template<class 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));} / / Appends the default line terminator to the end of the current xtd::text::basic_string_builder object. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append_line() {return append(xtd::basic_string<char_t> {xtd::environment::new_line()});} / Appends a copy of the specified string followed by the default line terminator to the end of the current xtd::text::basic_string_builder object. / Parameters value The string to append. / Returns A reference to this instance after the append operation has completed. / Exceptions xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / Remarks The capacity of this instance is adjusted as needed. / Notes to Callers / When you instantiate the xtd::text::basic_string_builder object by calling the xtd::text::basic_string_builder::basic_string_builder(xtd::size, xtd::size) constructor, both the length and the capacity of the xtd::text::basic_string_builder instance can grow beyond the value of its xtd::text::basic_string_builder::max_capacity property. This can occur particularly when you call the xtd::text::basic_string_builder::append and xtd::text::basic_string_builder::append_format methods to append small strings. basic_string_builder& append_line(const xtd::basic_string<char_t>& value) {return append(value).append_line();} / Returns a reference to the character at specified location pos. / Returns Reference to the requested character. / Exceptions xtd::index_out_of_range_exception If `index` is not within the range of the string. const_reference at(size_type pos) const {return operator [](pos);} / Returns a reference to the character at specified location pos. / Returns Reference to the requested character. / Exceptions xtd::index_out_of_range_exception If `index` is not within the range of the string. reference at(size_type pos) {return operator [](pos);} / Removes all characters from the current xtd::text::basic_string_builder instance. / Returns An object whose xtd::text::basic_string_builder::length is 0 (zero). / Remarks xtd::text::basic_string_builder::clear is a convenience method that is equivalent to setting the xtd::text::basic_string_builder::length property of the current instance to 0 (zero). / All pointers, references, and iterators are invalidated. basic_string_builder& clear() { chars_.clear(); return *this; } / Compares two character sequences. / Parameters str The other string to compare to. / Returns / * Negative value if *this appears before the character sequence specified by the arguments, in lexicographical order. / * Zero if both character sequences compare equivalent. / * Positive value if *this appears after the character sequence specified by the arguments, in lexicographical order. / Remarks Compares this string to str. / A character sequence consisting of count1 characters starting at data1 is compared to a character sequence consisting of count2 characters starting at data2 as follows: / * First, calculate the number of characters to compare, as if by size_type rlen = std::min(count1, count2). / * Then compare the sequences by calling traits_t::compare(data1, data2, rlen). For standard strings this function performs character-by-character lexicographical comparison. If the result is zero (the character sequences are equal so far), then their sizes are compared as follows: / / | Condition | Result | Return value | / | ----------------------------------------------------------— | ----------------------------— | ---------— | / | traits_t::compare(data1, data2, rlen) < 0 | data1 is less than data2 | < 0 | / | traits_t::compare(data1, data2, rlen) == 0 and size1 < size2 | data1 is less than data2 | < 0 | / | traits_t::compare(data1, data2, rlen) == 0 and size1 == size2 | data1 is equal to data2 | 0 | / | traits_t::compare(data1, data2, rlen) == 0 and size1 > size2 | data1 is greater than data2 | > 0 | / | traits_t::compare(data1, data2, rlen) > 0 | data1 is greater than data2 | > 0 | int32 compare(const basic_string_builder& str) const {return chars_.compare(str);} / Compares two character sequences. / Parameters pos1 The position of the first character in this string to compare. / count1 The number of characters of this string to compare. / str The other string to compare to. / Returns / * Negative value if *this appears before the character sequence specified by the arguments, in lexicographical order. / * Zero if both character sequences compare equivalent. / * Positive value if *this appears after the character sequence specified by the arguments, in lexicographical order. / Remarks Compares a [pos1, pos1 + count1) substring of this string to str. / * If count1 > size() - pos1, the substring is [pos1, size()). / A character sequence consisting of count1 characters starting at data1 is compared to a character sequence consisting of count2 characters starting at data2 as follows: / * First, calculate the number of characters to compare, as if by size_type rlen = std::min(count1, count2). / * Then compare the sequences by calling traits_t::compare(data1, data2, rlen). For standard strings this function performs character-by-character lexicographical comparison. If the result is zero (the character sequences are equal so far), then their sizes are compared as follows: / / | Condition | Result | Return value | / | ----------------------------------------------------------— | ----------------------------— | ---------— | / | traits_t::compare(data1, data2, rlen) < 0 | data1 is less than data2 | < 0 | / | traits_t::compare(data1, data2, rlen) == 0 and size1 < size2 | data1 is less than data2 | < 0 | / | traits_t::compare(data1, data2, rlen) == 0 and size1 == size2 | data1 is equal to data2 | 0 | / | traits_t::compare(data1, data2, rlen) == 0 and size1 > size2 | data1 is greater than data2 | > 0 | / | traits_t::compare(data1, data2, rlen) > 0 | data1 is greater than data2 | > 0 | int32 compare(size_type pos1, size_type count1, const basic_string_builder& str) const {return chars_.compare(pos1, count1, str);} / Compares two character sequences. / Parameters pos1 The position of the first character in this string to compare. / count1 The number of characters of this string to compare. / str The other string to compare to. / pos2 The position of the first character of the given string to compare. / Returns / * Negative value if *this appears before the character sequence specified by the arguments, in lexicographical order. / * Zero if both character sequences compare equivalent. / * Positive value if *this appears after the character sequence specified by the arguments, in lexicographical order. / Remarks Compares a [pos1, pos1 + count1) substring of this string to a substring [pos2, pos2 + count2) of str. / * If count1 > size() - pos1, the first substring is [pos1, size()). / * If count2 > str.size() - pos2, the second substring is [pos2, str.size()). / A character sequence consisting of count1 characters starting at data1 is compared to a character sequence consisting of count2 characters starting at data2 as follows: / * First, calculate the number of characters to compare, as if by size_type rlen = std::min(count1, count2). / * Then compare the sequences by calling traits_t::compare(data1, data2, rlen). For standard strings this function performs character-by-character lexicographical comparison. If the result is zero (the character sequences are equal so far), then their sizes are compared as follows: / / | Condition | Result | Return value | / | ----------------------------------------------------------— | ----------------------------— | ---------— | / | traits_t::compare(data1, data2, rlen) < 0 | data1 is less than data2 | < 0 | / | traits_t::compare(data1, data2, rlen) == 0 and size1 < size2 | data1 is less than data2 | < 0 | / | traits_t::compare(data1, data2, rlen) == 0 and size1 == size2 | data1 is equal to data2 | 0 | / | traits_t::compare(data1, data2, rlen) == 0 and size1 > size2 | data1 is greater than data2 | > 0 | / | traits_t::compare(data1, data2, rlen) > 0 | data1 is greater than data2 | > 0 | int32 compare(size_type pos1, size_type count1, const basic_string_builder& str, size_type pos2) const {return chars_.compare(pos1, count1, str, pos2);} / Compares two character sequences. / Parameters pos1 The position of the first character in this string to compare. / count1 The number of characters of this string to compare. / str The other string to compare to. / pos2 The position of the first character of the given string to compare. / count2 The number of characters of the given string to compare. / Returns A 32-bit signed integer that indicates whether this instance precedes, follows, or appears in the same position in the sort order as the value parameter: / * Negative value if *this appears before the character sequence specified by the arguments, in lexicographical order. / * Zero if both character sequences compare equivalent. / * Positive value if *this appears after the character sequence specified by the arguments, in lexicographical order. / Remarks Compares a [pos1, pos1 + count1) substring of this string to a substring [pos2, pos2 + count2) of str. / * If count1 > size() - pos1, the first substring is [pos1, size()). / * If count2 > str.size() - pos2, the second substring is [pos2, str.size()). / A character sequence consisting of count1 characters starting at data1 is compared to a character sequence consisting of count2 characters starting at data2 as follows: / * First, calculate the number of characters to compare, as if by size_type rlen = std::min(count1, count2). / * Then compare the sequences by calling traits_t::compare(data1, data2, rlen). For standard strings this function performs character-by-character lexicographical comparison. If the result is zero (the character sequences are equal so far), then their sizes are compared as follows: / / | Condition | Result | Return value | / | ----------------------------------------------------------— | ----------------------------— | ---------— | / | traits_t::compare(data1, data2, rlen) < 0 | data1 is less than data2 | < 0 | / | traits_t::compare(data1, data2, rlen) == 0 and size1 < size2 | data1 is less than data2 | < 0 | / | traits_t::compare(data1, data2, rlen) == 0 and size1 == size2 | data1 is equal to data2 | 0 | / | traits_t::compare(data1, data2, rlen) == 0 and size1 > size2 | data1 is greater than data2 | > 0 | / | traits_t::compare(data1, data2, rlen) > 0 | data1 is greater than data2 | > 0 | 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);} / Compares two character sequences. / Parameters s pointer to the character string to compare to. / Returns / * Negative value if *this appears before the character sequence specified by the arguments, in lexicographical order. / * Zero if both character sequences compare equivalent. / * Positive value if *this appears after the character sequence specified by the arguments, in lexicographical order. / Remarks Compares this string to the null-terminated character sequence beginning at the character pointed to by s with length traits_t::length(s). / A character sequence consisting of count1 characters starting at data1 is compared to a character sequence consisting of count2 characters starting at data2 as follows: / * First, calculate the number of characters to compare, as if by size_type rlen = std::min(count1, count2). / * Then compare the sequences by calling traits_t::compare(data1, data2, rlen). For standard strings this function performs character-by-character lexicographical comparison. If the result is zero (the character sequences are equal so far), then their sizes are compared as follows: / / | Condition | Result | Return value | / | ----------------------------------------------------------— | ----------------------------— | ---------— | / | traits_t::compare(data1, data2, rlen) < 0 | data1 is less than data2 | < 0 | / | traits_t::compare(data1, data2, rlen) == 0 and size1 < size2 | data1 is less than data2 | < 0 | / | traits_t::compare(data1, data2, rlen) == 0 and size1 == size2 | data1 is equal to data2 | 0 | / | traits_t::compare(data1, data2, rlen) == 0 and size1 > size2 | data1 is greater than data2 | > 0 | / | traits_t::compare(data1, data2, rlen) > 0 | data1 is greater than data2 | > 0 | int32 compare(const_pointer s) const {return chars_.compare(s);} / Compares two character sequences. / Parameters pos1 The position of the first character in this string to compare. / count1 The number of characters of this string to compare. / s pointer to the character string to compare to. / Returns / * Negative value if *this appears before the character sequence specified by the arguments, in lexicographical order. / * Zero if both character sequences compare equivalent. / * Positive value if *this appears after the character sequence specified by the arguments, in lexicographical order. / Remarks Compares a [pos1, pos1 + count1) substring of this string to the null-terminated character sequence beginning at the character pointed to by s with length traits_t::length(s). / * If count1 > size() - pos1, the substring is [pos1$ , size()). @remarks A character sequence consisting ofcount1characters starting atdata1is compared to a character sequence consisting ofcount2characters starting atdata2as follows: First, calculate the number of characters to compare, as if by size_type rlen = std::min(count1, count2). Then compare the sequences by calling traits_t::compare(data1, data2, rlen)`. For standard strings this function performs character-by-character lexicographical comparison. If the result is zero (the character sequences are equal so far), then their sizes are compared as follows: Condition Result Return value traits_t::compare(data1, data2, rlen) < 0 data1 is less than data2 < 0 traits_t::compare(data1, data2, rlen) == 0 and size1 < size2 data1 is less than data2 < 0 traits_t::compare(data1, data2, rlen) == 0 and size1 == size2 data1 is equal to data2 0 traits_t::compare(data1, data2, rlen) == 0 and size1 > size2 data1 is greater than data2 > 0 traits_t::compare(data1, data2, rlen) > 0 data1 is greater than data2 > 0
int32	compare (size_type pos1, size_type count1, const_pointer s) const
int32	compare (size_type pos1, size_type count1, const_pointer s, size_type count2) const
	Compares two character sequences.
size_type	copy (pointer dest, size_type count) const
	Copies a substring [pos, pos + count) to character string pointed to by dest. If the requested substring lasts past the end of the string, or if count == npos, the copied substring is [pos, size()).
size_type	copy (pointer dest, size_type count, size_type pos) const
	Copies a substring [pos, pos + count) to character string pointed to by dest. If the requested substring lasts past the end of the string, or if count == npos, the copied substring is [pos, size()).
void	copy_to (xtd::size source_index, xtd::array< value_type > &destination, xtd::size destination_index, xtd::size destination_count) const
	Copies the characters from a specified segment of this instance to a specified segment of a destination xtd::text::basic_string_builder::value_type array.
bool	equals (const object &obj) const noexcept override
	Determines whether this instance and a specified object, which must also be a xtd::text::basic_string_builder object, have the same value.
bool	equals (const basic_string_builder &value) const noexcept override
	Determines whether this instance and another specified xtd::text::basic_string_builder object have the same value.
size_type	ensure_capacity (size_type capacity)
	Ensures that the capacity of this instance of xtd::text::basic_string_builder is at least the specified value.
basic_string_builder &	erase ()
	Removes specified characters from the string.
basic_string_builder &	erase (size_type index)
	Removes specified characters from the string.
basic_string_builder &	erase (size_type index, size_type count)
	Removes specified characters from the string.
iterator	erase (const_iterator position)
	Removes specified characters from the string.
iterator	erase (const_iterator first, const_iterator last)
	Removes specified characters from the string.
size_type	find (const basic_string_builder &str) const
	Finds the first substring equal to the given character sequence. Search begins at 0, i.e. the found substring must not begin in a position preceding 0.
size_type	find (const basic_string_builder &str, size_type pos) const
	Finds the first substring equal to the given character sequence. Search begins at pos, i.e. the found substring must not begin in a position preceding pos.
size_type	find (const_pointer s, size_type pos, size_type count) const
	Finds the first substring equal to the given character sequence. Search begins at pos, i.e. the found substring must not begin in a position preceding pos.
size_type	find (const_pointer s) const
	Finds the first substring equal to the given character sequence. Search begins at 0, i.e. the found substring must not begin in a position preceding 0.
size_type	find (const_pointer s, size_type pos) const
	Finds the first substring equal to the given character sequence. Search begins at pos, i.e. the found substring must not begin in a position preceding pos.
size_type	find (value_type ch) const
	Finds the first substring equal to the given character sequence. Search begins at 0, i.e. the found substring must not begin in a position preceding 0.
size_type	find (value_type ch, size_type pos) const
	Finds the first substring equal to the given character sequence. Search begins at pos, i.e. the found substring must not begin in a position preceding pos.
size_type	find_first_of (const basic_string_builder &str) const
	Finds the first character equal to one of the characters in the given character sequence. The search considers only the range [pos, size()). If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.
size_type	find_first_of (const basic_string_builder &str, size_type pos) const
	Finds the first character equal to one of the characters in the given character sequence. The search considers only the range [pos, size()). If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.
size_type	find_first_of (const_pointer s, size_type pos, size_type count) const
	Finds the first character equal to one of the characters in the given character sequence. The search considers only the range [pos, size()). If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.
size_type	find_first_of (const_pointer s) const
	Finds the first character equal to one of the characters in the given character sequence. The search considers only the range [pos, size()). If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.
size_type	find_first_of (const_pointer s, size_type pos) const
	Finds the first character equal to one of the characters in the given character sequence. The search considers only the range [pos, size()). If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.
size_type	find_first_of (value_type ch) const
	Finds the first character equal to one of the characters in the given character sequence. The search considers only the range [pos, size()). If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.
size_type	find_first_of (value_type ch, size_type pos) const
	Finds the first character equal to one of the characters in the given character sequence. The search considers only the range [pos, size()). If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.
size_type	find_first_not_of (const basic_string_builder &str) const
	Finds the first character equal to none of the characters in the given character sequence. The search considers only the range [pos, size()). If all characters in the range can be found in the given character sequence, xtd::text::basic_string_builder::npos will be returned.
size_type	find_first_not_of (const basic_string_builder &str, size_type pos) const
	Finds the first character equal to none of the characters in the given character sequence. The search considers only the range [pos, size()). If all characters in the range can be found in the given character sequence, xtd::text::basic_string_builder::npos will be returned.
size_type	find_first_not_of (const_pointer s, size_type pos, size_type count) const
	Finds the first character equal to none of the characters in the given character sequence. The search considers only the range [pos, size()). If all characters in the range can be found in the given character sequence, xtd::text::basic_string_builder::npos will be returned.
size_type	find_first_not_of (const_pointer s) const
	Finds the first character equal to none of the characters in the given character sequence. The search considers only the range [pos, size()). If all characters in the range can be found in the given character sequence, xtd::text::basic_string_builder::npos will be returned.
size_type	find_first_not_of (const_pointer s, size_type pos) const
	Finds the first character equal to none of the characters in the given character sequence. The search considers only the range [pos, size()). If all characters in the range can be found in the given character sequence, xtd::text::basic_string_builder::npos will be returned.
size_type	find_first_not_of (value_type ch) const
	Finds the first character equal to none of the characters in the given character sequence. The search considers only the range [pos, size()). If all characters in the range can be found in the given character sequence, xtd::text::basic_string_builder::npos will be returned.
size_type	find_first_not_of (value_type ch, size_type pos) const
	Finds the first character equal to none of the characters in the given character sequence. The search considers only the range [pos, size()). If all characters in the range can be found in the given character sequence, xtd::text::basic_string_builder::npos will be returned.
size_type	find_last_of (const basic_string_builder &str) const
	Finds the last character equal to one of characters in the given character sequence. The exact search algorithm is not specified. The search considers only the range [​0​, pos]. If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.
size_type	find_last_of (const basic_string_builder &str, size_type pos) const
	Finds the last character equal to one of characters in the given character sequence. The exact search algorithm is not specified. The search considers only the range [​0​, pos]. If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.
size_type	find_last_of (const_pointer s, size_type pos, size_type count) const
	Finds the last character equal to one of characters in the given character sequence. The exact search algorithm is not specified. The search considers only the range [​0​, pos]. If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.
size_type	find_last_of (const_pointer s) const
	Finds the last character equal to one of characters in the given character sequence. The exact search algorithm is not specified. The search considers only the range [​0​, pos]. If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.
size_type	find_last_of (const_pointer s, size_type pos) const
	Finds the last character equal to one of characters in the given character sequence. The exact search algorithm is not specified. The search considers only the range [​0​, pos]. If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.
size_type	find_last_of (value_type ch) const
	Finds the last character equal to one of characters in the given character sequence. The exact search algorithm is not specified. The search considers only the range [​0​, pos]. If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.
size_type	find_last_of (value_type ch, size_type pos) const
	Finds the last character equal to one of characters in the given character sequence. The exact search algorithm is not specified. The search considers only the range [​0​, pos]. If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.
size_type	find_last_not_of (const basic_string_builder &str) const
	Finds the last character equal to none of the characters in the given character sequence. The search considers only the range [​0​, pos]. If all characters in the range can be found in the given character sequence,xtd::text::basic_string_builder::npos will be returned.
size_type	find_last_not_of (const basic_string_builder &str, size_type pos) const
	Finds the last character equal to none of the characters in the given character sequence. The search considers only the range [​0​, pos]. If all characters in the range can be found in the given character sequence,xtd::text::basic_string_builder::npos will be returned.
size_type	find_last_not_of (const_pointer s, size_type pos, size_type count) const
	Finds the last character equal to none of the characters in the given character sequence. The search considers only the range [​0​, pos]. If all characters in the range can be found in the given character sequence,xtd::text::basic_string_builder::npos will be returned.
size_type	find_last_not_of (const_pointer s) const
	Finds the last character equal to none of the characters in the given character sequence. The search considers only the range [​0​, pos]. If all characters in the range can be found in the given character sequence,xtd::text::basic_string_builder::npos will be returned.
size_type	find_last_not_of (const_pointer s, size_type pos) const
	Finds the last character equal to none of the characters in the given character sequence. The search considers only the range [​0​, pos]. If all characters in the range can be found in the given character sequence,xtd::text::basic_string_builder::npos will be returned.
size_type	find_last_not_of (value_type ch) const
	Finds the last character equal to none of the characters in the given character sequence. The search considers only the range [​0​, pos]. If all characters in the range can be found in the given character sequence,xtd::text::basic_string_builder::npos will be returned.
size_type	find_last_not_of (value_type ch, size_type pos) const
	Finds the last character equal to none of the characters in the given character sequence. The search considers only the range [​0​, pos]. If all characters in the range can be found in the given character sequence,xtd::text::basic_string_builder::npos will be returned.
allocator_type	get_allocator () const
	Returns the allocator associated with the string.
virtual const base_type &	get_base_type () const noexcept
	Returns the underlying base type.
xtd::size	get_hash_code () const noexcept override
	Returns the hash code for this basic_string_builder.
basic_string_builder &	insert (size_type index, const xtd::basic_string< char_t > &value)
	Inserts a string into this instance at the specified character position.
basic_string_builder &	insert (size_type index, const xtd::basic_string< char_t > &value, size_type count)
	Inserts one or more copies of a specified string into this instance at the specified character position.
basic_string_builder &	insert (size_type index, xtd::boolean value)
	Inserts the string representation of a boolean value into this instance at the specified character position.
basic_string_builder &	insert (size_type index, xtd::byte value)
	Inserts the string representation of a specified 8-bit unsigned integer into this instance at the specified character position.
basic_string_builder &	insert (size_type index, xtd::decimal value)
	Inserts the string representation of a specified 8decimal into this instance at the specified character position.
basic_string_builder &	insert (size_type index, double value)
	Inserts the string representation of a specified double into this instance at the specified character position.
basic_string_builder &	insert (size_type index, xtd::single value)
	Inserts the string representation of a specified single into this instance at the specified character position.
basic_string_builder &	insert (size_type index, xtd::int16 value)
	Inserts the string representation of a specified 16-bit signed integer into this instance at the specified character position.
basic_string_builder &	insert (size_type index, xtd::int32 value)
	Inserts the string representation of a specified 32-bit signed integer into this instance at the specified character position.
basic_string_builder &	insert (size_type index, xtd::int64 value)
	Inserts the string representation of a specified 64-bit signed integer into this instance at the specified character position.
basic_string_builder &	insert (size_type index, xtd::sbyte value)
	Inserts the string representation of a specified 8-bit signed integer into this instance at the specified character position.
basic_string_builder &	insert (size_type index, xtd::uint16 value)
	Inserts the string representation of a specified 16-bit unsigned integer into this instance at the specified character position.
basic_string_builder &	insert (size_type index, xtd::uint32 value)
	Inserts the string representation of a specified 32-bit unsigned integer into this instance at the specified character position.
basic_string_builder &	insert (size_type index, xtd::uint64 value)
	Inserts the string representation of a specified 64-bit unsigned integer into this instance at the specified character position.
basic_string_builder &	insert (size_type index, value_type value)
	Inserts the string representation of a specified Unicode character into this instance at the specified character position.
basic_string_builder &	insert (size_type index, value_type value, size_type repeat_count)
	Inserts a specified number of copies of the string representation of a Unicode character to this instance at the specified character position.
template<class object_t>
basic_string_builder &	insert (size_type index, object_t value)
	Inserts the string representation of a specified object into this instance at the specified character position.
basic_string_builder &	insert (size_type index, size_type count, value_type ch)
	Inserts characters into the string.
basic_string_builder &	insert (size_type index, const basic_string_builder &str, size_type s_index, size_type count)
	Inserts characters into the string.
basic_string_builder &	replace (const xtd::basic_string< char_t > &old_value, const xtd::basic_string< char_t > &new_value) noexcept
	Inserts characters into the string.
basic_string_builder &	replace (const_iterator first, const_iterator last, const basic_string_builder &str)
	Replaces, within a substring of this instance, all occurrences of a specified string with another specified string.
basic_string_builder &	replace (size_type pos, size_type count, const basic_string_builder &str, size_type pos2)
	Replaces the characters in the range [begin() + pos, begin() + std::min(pos + count, size())) or [first, last) with given characters.
basic_string_builder &	replace (size_type pos, size_type count, const basic_string_builder &str, size_type pos2, size_type count2)
	Replaces the characters in the range [begin() + pos, begin() + std::min(pos + count, size())) or [first, last) with given characters.
basic_string_builder &	replace (size_type pos, size_type count, const_pointer cstr, size_type count2)
	Replaces the characters in the range [begin() + pos, begin() + std::min(pos + count, size())) or [first, last) with given characters.
basic_string_builder &	replace (const_iterator first, const_iterator last, const_pointer cstr)
	Replaces the characters in the range [begin() + pos, begin() + std::min(pos + count, size())) or [first, last) with given characters.
basic_string_builder &	replace (size_type pos, size_type count, size_type count2, value_type ch)
	Replaces the characters in the range [begin() + pos, begin() + std::min(pos + count, size())) or [first, last) with given characters.
template<class input_iterator_t>
basic_string_builder &	replace (const_iterator first, const_iterator last, input_iterator_t first2, input_iterator_t last2)
	Replaces the characters in the range [begin() + pos, begin() + std::min(pos + count, size())) or [first, last) with given characters.
size_type	rfind (const basic_string_builder &str) const
	Replaces the characters in the range [begin() + pos, begin() + std::min(pos + count, size())) or [first, last) with given characters.
size_type	rfind (const basic_string_builder &str, size_type pos) const
	Finds the last substring that is equal to the given character sequence. The search begins at pos and proceeds from right to left (thus, the found substring, if any, cannot begin in a position following pos). If xtd::text::basic_string_builder::npos or any value not smaller than xtd::text::basic_string_builder::size() - 1 is passed as pos, the whole string will be searched.
size_type	rfind (const_pointer s, size_type pos, size_type count) const
	Finds the last substring that is equal to the given character sequence. The search begins at pos and proceeds from right to left (thus, the found substring, if any, cannot begin in a position following pos). If xtd::text::basic_string_builder::npos or any value not smaller than xtd::text::basic_string_builder::size() - 1 is passed as pos, the whole string will be searched.
size_type	rfind (value_type ch) const
	Finds the last substring that is equal to the given character sequence. The search begins at xtd::text::basic_string_builder::nposand proceeds from right to left (thus, the found substring, if any, cannot begin in a position following xtd::text::basic_string_builder::npos). If xtd::text::basic_string_builder::npos or any value not smaller than xtd::text::basic_string_builder::size() - 1 is passed as xtd::text::basic_string_builder::npos, the whole string will be searched. / @param s The pointer to a character string to search for. / @return Position of the first character of the found substring or xtd::text::basic_string_builder::npos if no such substring is found. / @remarks Finds the first substring equal to the character string pointed to bys. The length of the string is determined by the first null character usingtraits_t::length(s). / @remarks If [s,s + traits_t::length(s)) is not a valid range, the behavior is undefined. size_type rfind(const_pointer s) const {return chars_.rfind(s);} / @brief Finds the last substring that is equal to the given character sequence. The search begins atposand proceeds from right to left (thus, the found substring, if any, cannot begin in a position followingpos). If xtd::text::basic_string_builder::npos or any value not smaller than xtd::text::basic_string_builder::size() - 1 is passed aspos, the whole string will be searched. / @param s The pointer to a character string to search for. / @param pos The position at which to start the search / @return Position of the first character of the found substring or xtd::text::basic_string_builder::npos if no such substring is found. / @remarks Finds the first substring equal to the character string pointed to bys. The length of the string is determined by the first null character usingtraits_t::length(s). / @remarks If [s,s + traits_t::length(s)) is not a valid range, the behavior is undefined. size_type rfind(const_pointer s, size_type pos) const {return chars_.rfind(s, pos);} / @brief Finds the last substring that is equal to the given character sequence. The search begins at xtd::text::basic_string_builder::npos and proceeds from right to left (thus, the found substring, if any, cannot begin in a position following xtd::text::basic_string_builder::npos). If xtd::text::basic_string_builder::npos or any value not smaller than xtd::text::basic_string_builder::size() - 1 is passed as xtd::text::basic_string_builder::npos, the whole string will be searched.
size_type	rfind (value_type ch, size_type pos) const
	Finds the last substring that is equal to the given character sequence. The search begins at pos and proceeds from right to left (thus, the found substring, if any, cannot begin in a position following pos). If xtd::text::basic_string_builder::npos or any value not smaller than xtd::text::basic_string_builder::size() - 1 is passed as pos, the whole string will be searched.
void	shrink_to_fit ()
	Requests the removal of unused capacity.
basic_string_builder	substr () const
	Returns a substring [pos, pos + count). If the requested substring extends past the end of the string, i.e. the count is greater than size() - pos (e.g. if count == xtd::text::basic_string_builder::npos), the returned substring is [pos, size()).
basic_string_builder	substr (size_type pos) const
	Returns a substring [pos, pos + count). If the requested substring extends past the end of the string, i.e. the count is greater than size() - pos (e.g. if count == xtd::text::basic_string_builder::npos), the returned substring is [pos, size()).
basic_string_builder	substr (size_type pos, size_type count) const
	Returns a substring [pos, pos + count). If the requested substring extends past the end of the string, i.e. the count is greater than size() - pos (e.g. if count == xtd::text::basic_string_builder::npos), the returned substring is [pos, size()).
void	swap (basic_string_builder &other) noexcept
	Exchanges the contents of the string with those of other. All iterators and references may be invalidated.
xtd::string	to_string () const noexcept override
	Converts the value of this instance to a xtd::text::basic_string_builder <char>.

Public Operators
const_reference	operator[] (xtd::size index) const
	Returns a reference to the character at specified location index.
reference	operator[] (xtd::size index)
	Returns a reference to the character at specified location index.
	operator const base_type & () const noexcept
	Returns a reference to the underlying base type.
	operator base_type & () noexcept
	Returns a reference to the underlying base type.
basic_string_builder &	operator= (const basic_string_builder &str) noexcept
	Copy assignment operator. Replaces the contents with a copy of the contents of str.
basic_string_builder &	operator= (basic_string_builder &&str) noexcept
	Move assignment operator. Replaces the contents with those of other using move semantics (i.e. the data in str is moved from str into this string). str is in a valid but unspecified state afterwards.
basic_string_builder &	operator= (const std::basic_string< value_type > &str) noexcept
	Copy assignment operator. Replaces the contents with a copy of the contents of str.
basic_string_builder &	operator= (std::basic_string< value_type > &&str) noexcept
	Copy assignment operator. Replaces the contents with a copy of the contents of str.
basic_string_builder &	operator= (const xtd::basic_string< value_type > &str) noexcept
	Copy assignment operator. Replaces the contents with a copy of the contents of str.
basic_string_builder &	operator= (xtd::basic_string< value_type > &&str) noexcept
	Copy assignment operator. Replaces the contents with a copy of the contents of str.
basic_string_builder &	operator= (const_pointer str)
	Copy assignment operator. Replaces the contents with a copy of the contents of str.
basic_string_builder &	operator= (value_type character)
	Copy assignment operator. Replaces the contents with the specified character.
basic_string_builder &	operator= (const std::initializer_list< value_type > &il)
	Copy assignment operator. Replaces the contents with a copy of the contents of the specified initializer list.
basic_string_builder &	operator+= (const basic_string_builder &str)
	Addition assignment operator. Appends additional characters to the string.
basic_string_builder &	operator+= (basic_string_builder &&str)
	Addition assignment operator. Appends additional characters to the string.
basic_string_builder &	operator+= (const_pointer str)
	Addition assignment operator. Appends additional characters to the string.
basic_string_builder &	operator+= (value_type ch)
	Addition assignment operator. Appends additional characters to the string.

Additional Inherited Members
	object ()=default
	Create a new instance of the ultimate base class object.
virtual type_object	get_type () const noexcept
	Gets the type of the current instance.
template<class object_t>
xtd::unique_ptr_object< object_t >	memberwise_clone () const
	Creates a shallow copy of the current object.
virtual bool	equals (const type_t &) const noexcept=0
	Indicates whether the current object is equal to another object of the same type.
template<class object_a_t, class object_b_t>
static bool	equals (const object_a_t &object_a, const object_b_t &object_b) noexcept
	Determines whether the specified object instances are considered equal.
template<class object_a_t, class object_b_t>
static bool	reference_equals (const object_a_t &object_a, const object_b_t &object_b) noexcept
	Determines whether the specified object instances are the same instance.

Member Function Documentation

compare()

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

int32 xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::compare ( size_type pos1, size_type count1, const_pointer s, size_type count2 ) const

inline

Compares two character sequences.

Parameters

pos1	The position of the first character in this string to compare.
count1	The number of characters of this string to compare.
s	pointer to the character string to compare to.
count2	The number of characters of the given string to compare.

Returns

• Negative value if *this appears before the character sequence specified by the arguments, in lexicographical order.
• Zero if both character sequences compare equivalent.
• Positive value if *this appears after the character sequence specified by the arguments, in lexicographical order.

Remarks

Compares a [pos1, pos1 + count1) substring of this string to the characters in the range [s, s + count2). The characters in [s, s + count2) may include null characters.

• If count1 > size() - pos1, the substring is [pos1, size()).

A character sequence consisting of count1 characters starting at data1 is compared to a character sequence consisting of count2 characters starting at data2 as follows:

• First, calculate the number of characters to compare, as if by size_type rlen = std::min(count1, count2).
• Then compare the sequences by calling traits_t::compare(data1, data2, rlen). For standard strings this function performs character-by-character lexicographical comparison. If the result is zero (the character sequences are equal so far), then their sizes are compared as follows:

Condition	Result	Return value
traits_t::compare(data1, data2, rlen) < 0	data1 is less than data2	< 0
traits_t::compare(data1, data2, rlen) == 0 and size1 < size2	data1 is less than data2	< 0
traits_t::compare(data1, data2, rlen) == 0 and size1 == size2	data1 is equal to data2	0
traits_t::compare(data1, data2, rlen) == 0 and size1 > size2	data1 is greater than data2	> 0
traits_t::compare(data1, data2, rlen) > 0	data1 is greater than data2	> 0

copy() [1/2]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::copy ( pointer dest, size_type count ) const

inline

Copies a substring [pos, pos + count) to character string pointed to by dest. If the requested substring lasts past the end of the string, or if count == npos, the copied substring is [pos, size()).

Parameters

dest	The pointer to the destination character string.
count	length of the substring.

Returns

The number of characters copied.

Remarks

The resulting character string is not null-terminated.

copy() [2/2]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::copy ( pointer dest, size_type count, size_type pos ) const

inline

Copies a substring [pos, pos + count) to character string pointed to by dest. If the requested substring lasts past the end of the string, or if count == npos, the copied substring is [pos, size()).

Parameters

dest	The pointer to the destination character string.
count	length of the substring.
pos	The position of the first character to include.

Returns

The number of characters copied.

Remarks

The resulting character string is not null-terminated.

copy_to()

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

void xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::copy_to ( xtd::size source_index, xtd::array< value_type > & destination, xtd::size destination_index, xtd::size destination_count ) const

inline

Copies the characters from a specified segment of this instance to a specified segment of a destination xtd::text::basic_string_builder::value_type array.

Parameters

source_index	The starting position in this instance where characters will be copied from. The index is zero-based.
destination	The array where characters will be copied.
destination_index	The starting position in destination where characters will be copied. The index is zero-based.
destination_count	The number of characters to be copied.

Exceptions

xtd::argument_out_of_range_exception

`source_index` is greater than length -or- `destination_index` + 'destination_count' greater than destination size.

Remarks

The xtd::text::basic_string_builder::copy_to method is intended to be used in the rare situation when you need to efficiently copy successive sections of a xtd::text::basic_string_builder object to an array. The array should be a fixed size, preallocated, reusable, and possibly globally accessible.

For example, your code could populate a xtd::text::basic_string_builder object with a large number of characters then use the xtd::text::basic_string_builder::copy_to method to copy small, successive pieces of the xtd::text::basic_string_builder object to an array where the pieces are processed. When all the data in the xtd::text::basic_string_builder object is processed, the size of the xtd::text::basic_string_builder object is set to zero and the cycle is repeated.

equals() [1/2]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

bool xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::equals ( const object & obj ) const

inlineoverridevirtualnoexcept

Determines whether this instance and a specified object, which must also be a xtd::text::basic_string_builder object, have the same value.

Parameters

obj	The basic_string_builder to compare to this instance.

Returns

true if obj is a xtd::text::basic_string_builder and its value is the same as this instance; otherwise, false.

Reimplemented from xtd::object.

equals() [2/2]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

bool xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::equals ( const basic_string_builder< char_t, traits_t, allocator_t > & value ) const

inlineoverridenoexcept

Determines whether this instance and another specified xtd::text::basic_string_builder object have the same value.

Parameters

value

The basic_string_builder to compare to this instance.

Returns

true if the value of the value parameter is the same as the value of this instance; otherwise, false.

Remarks

This method performs an ordinal (case-sensitive) comparison.

ensure_capacity()

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::ensure_capacity ( size_type capacity )

inline

Ensures that the capacity of this instance of xtd::text::basic_string_builder is at least the specified value.

Parameters

capacity

The minimum capacity to ensure.

Returns

The new capacity of this instance.

Exceptions

xtd::argument_out_of_range_exception

Enlarging the value of this instance would exceed Enlarging the value of this instance would exceed MaxCapacity.::max_capacity.

Remarks

If the current capacity is less than the capacity parameter, memory for this instance is reallocated to hold at least capacity number of characters; otherwise, no memory is changed.

erase() [1/5]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::erase ( )

inline

Removes specified characters from the string.

Returns

This current instance of xtd::text::basic_string_builder.

Remarks

Removes std::min(count, size() - index) characters starting at index.

erase() [2/5]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::erase ( size_type index )

inline

Removes specified characters from the string.

Parameters

index

The first character to remove.

Returns

This current instance of xtd::text::basic_string_builder.

Remarks

Removes std::min(count, size() - index) characters starting at index.

erase() [3/5]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::erase ( size_type index, size_type count )

inline

Removes specified characters from the string.

Parameters

index	The first character to remove.
count	The number of characters to remove.

Returns

This current instance of xtd::text::basic_string_builder.

Remarks

Removes std::min(count, size() - index) characters starting at index.

erase() [4/5]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

iterator xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::erase ( const_iterator position )

inline

Removes specified characters from the string.

Parameters

position

The iterator to the character to remove.

Returns

The Iterator pointing to the character immediately following the character erased, or end() if no such character exists.

Remarks

Removes the character at position.

If position is not a dereferenceable iterator on *this, the behavior is undefined.

erase() [5/5]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

iterator xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::erase ( const_iterator first, const_iterator last )

inline

Removes specified characters from the string.

Parameters

first	The first iterator of the range of the characters to remove.
last	The last iterator of the range of the characters to remove.

Returns

The iterator pointing to the character last pointed to before the erase, or end() if no such character exists.

Remarks

Removes the characters in the range [first, last).

If first or last is not a valid iterator on *this, or [first, last) is not a valid range, the behavior is undefined.

find() [1/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find ( const basic_string_builder< char_t, traits_t, allocator_t > & str ) const

inline

Finds the first substring equal to the given character sequence. Search begins at 0, i.e. the found substring must not begin in a position preceding 0.

Returns

Position of the first character of the found substring or xtd::text::basic_string_builder::npos if no such substring is found.

Remarks

Finds the first substring equal to str.

find() [2/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find ( const basic_string_builder< char_t, traits_t, allocator_t > & str, size_type pos ) const

inline

Finds the first substring equal to the given character sequence. Search begins at pos, i.e. the found substring must not begin in a position preceding pos.

Parameters

str	The string to search for.
pos	The position at which to start the search

Returns

Position of the first character of the found substring or xtd::text::basic_string_builder::npos if no such substring is found.

Remarks

Finds the first substring equal to str.

find() [3/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find ( const_pointer s, size_type pos, size_type count ) const

inline

Finds the first substring equal to the given character sequence. Search begins at pos, i.e. the found substring must not begin in a position preceding pos.

Parameters

str	The string to search for.
pos	The position at which to start the search
count	The length of substring to search for.

Returns

Position of the first character of the found substring or xtd::text::basic_string_builder::npos if no such substring is found.

Remarks

Finds the first substring equal to the range [s, s + count).

This range may contain null characters. If [s, s + count) is not a valid range, the behavior is undefined.

find() [4/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find ( const_pointer s ) const

inline

Finds the first substring equal to the given character sequence. Search begins at 0, i.e. the found substring must not begin in a position preceding 0.

Parameters

s	The pointer to a character string to search for.

Returns

Position of the first character of the found substring or xtd::text::basic_string_builder::npos if no such substring is found.

Remarks

Finds the first substring equal to the character string pointed to by s. The length of the string is determined by the first null character using traits_t::length(s).

If [s, s + traits_t::length(s)) is not a valid range, the behavior is undefined.

find() [5/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find ( const_pointer s, size_type pos ) const

inline

Finds the first substring equal to the given character sequence. Search begins at pos, i.e. the found substring must not begin in a position preceding pos.

Parameters

s	The pointer to a character string to search for.
pos	The position at which to start the search

Returns

Position of the first character of the found substring or xtd::text::basic_string_builder::npos if no such substring is found.

Remarks

Finds the first substring equal to the character string pointed to by s. The length of the string is determined by the first null character using traits_t::length(s).

If [s, s + traits_t::length(s)) is not a valid range, the behavior is undefined.

find() [6/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find ( value_type ch ) const

inline

Finds the first substring equal to the given character sequence. Search begins at 0, i.e. the found substring must not begin in a position preceding 0.

Parameters

ch	The character to search for.

Returns

Position of the first character of the found substring or xtd::text::basic_string_builder::npos if no such substring is found.

Remarks

Finds the first character ch (treated as a single-character substring by the formal rules below).

find() [7/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find ( value_type ch, size_type pos ) const

inline

Finds the first substring equal to the given character sequence. Search begins at pos, i.e. the found substring must not begin in a position preceding pos.

Parameters

ch	The character to search for.
pos	The position at which to start the search

Returns

Position of the first character of the found substring or xtd::text::basic_string_builder::npos if no such substring is found.

Remarks

Finds the first character ch (treated as a single-character substring by the formal rules below).

find_first_of() [1/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_first_of ( const basic_string_builder< char_t, traits_t, allocator_t > & str ) const

inline

Finds the first character equal to one of the characters in the given character sequence. The search considers only the range [pos, size()). If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.

Parameters

str	The string identifying characters to search for.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in str.

find_first_of() [2/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_first_of ( const basic_string_builder< char_t, traits_t, allocator_t > & str, size_type pos ) const

inline

Finds the first character equal to one of the characters in the given character sequence. The search considers only the range [pos, size()). If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.

Parameters

str	The string identifying characters to search for.
pos	The position at which to begin searching.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in str.

find_first_of() [3/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_first_of ( const_pointer s, size_type pos, size_type count ) const

inline

Finds the first character equal to one of the characters in the given character sequence. The search considers only the range [pos, size()). If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.

Parameters

s	The pointer to a character string identifying characters to search for.
pos	The position at which to begin searching.
count	The length of character string identifying characters to search for.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in the range [s, s + count). This range can include null characters.

If [s, s + count) is not a valid range, the behavior is undefined.

find_first_of() [4/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_first_of ( const_pointer s ) const

inline

Finds the first character equal to one of the characters in the given character sequence. The search considers only the range [pos, size()). If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.

Parameters

s	The pointer to a character string identifying characters to search for.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in character string pointed to by s. The length of the string is determined by the first null character using traits_t::length(s).

If [s, s + traits_t::length(s)) is not a valid range, the behavior is undefined.

find_first_of() [5/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_first_of ( const_pointer s, size_type pos ) const

inline

Finds the first character equal to one of the characters in the given character sequence. The search considers only the range [pos, size()). If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.

Parameters

s	The pointer to a character string identifying characters to search for.
pos	The position at which to begin searching.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in character string pointed to by s. The length of the string is determined by the first null character using traits_t::length(s).

If [s, s + traits_t::length(s)) is not a valid range, the behavior is undefined.

find_first_of() [6/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_first_of ( value_type ch ) const

inline

Finds the first character equal to one of the characters in the given character sequence. The search considers only the range [pos, size()). If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.

Parameters

ch	The character to search for.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to ch.

find_first_of() [7/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_first_of ( value_type ch, size_type pos ) const

inline

Finds the first character equal to one of the characters in the given character sequence. The search considers only the range [pos, size()). If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.

Parameters

ch	The character to search for.
pos	The position at which to begin searching.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to ch.

find_first_not_of() [1/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_first_not_of ( const basic_string_builder< char_t, traits_t, allocator_t > & str ) const

inline

Finds the first character equal to none of the characters in the given character sequence. The search considers only the range [pos, size()). If all characters in the range can be found in the given character sequence, xtd::text::basic_string_builder::npos will be returned.

Parameters

str	The string identifying characters to search for.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in str.

find_first_not_of() [2/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_first_not_of ( const basic_string_builder< char_t, traits_t, allocator_t > & str, size_type pos ) const

inline

Finds the first character equal to none of the characters in the given character sequence. The search considers only the range [pos, size()). If all characters in the range can be found in the given character sequence, xtd::text::basic_string_builder::npos will be returned.

Parameters

str	The string identifying characters to search for.
pos	The position at which to begin searching.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in str.

find_first_not_of() [3/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_first_not_of ( const_pointer s, size_type pos, size_type count ) const

inline

Finds the first character equal to none of the characters in the given character sequence. The search considers only the range [pos, size()). If all characters in the range can be found in the given character sequence, xtd::text::basic_string_builder::npos will be returned.

Parameters

s	The pointer to a character string identifying characters to search for.
pos	The position at which to begin searching.
count	The length of character string identifying characters to search for.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in the range [s, s + count). This range can include null characters.

If [s, s + count) is not a valid range, the behavior is undefined.

find_first_not_of() [4/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_first_not_of ( const_pointer s ) const

inline

Finds the first character equal to none of the characters in the given character sequence. The search considers only the range [pos, size()). If all characters in the range can be found in the given character sequence, xtd::text::basic_string_builder::npos will be returned.

Parameters

s	The pointer to a character string identifying characters to search for.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in character string pointed to by s. The length of the string is determined by the first null character using traits_t::length(s).

If [s, s + traits_t::length(s)) is not a valid range, the behavior is undefined.

find_first_not_of() [5/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_first_not_of ( const_pointer s, size_type pos ) const

inline

Finds the first character equal to none of the characters in the given character sequence. The search considers only the range [pos, size()). If all characters in the range can be found in the given character sequence, xtd::text::basic_string_builder::npos will be returned.

Parameters

s	The pointer to a character string identifying characters to search for.
pos	The position at which to begin searching.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in character string pointed to by s. The length of the string is determined by the first null character using traits_t::length(s).

If [s, s + traits_t::length(s)) is not a valid range, the behavior is undefined.

find_first_not_of() [6/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_first_not_of ( value_type ch ) const

inline

Finds the first character equal to none of the characters in the given character sequence. The search considers only the range [pos, size()). If all characters in the range can be found in the given character sequence, xtd::text::basic_string_builder::npos will be returned.

Parameters

ch	The character to search for.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to ch.

find_first_not_of() [7/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_first_not_of ( value_type ch, size_type pos ) const

inline

Finds the first character equal to none of the characters in the given character sequence. The search considers only the range [pos, size()). If all characters in the range can be found in the given character sequence, xtd::text::basic_string_builder::npos will be returned.

Parameters

ch	The character to search for.
pos	The position at which to begin searching.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to ch.

find_last_of() [1/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_last_of ( const basic_string_builder< char_t, traits_t, allocator_t > & str ) const

inline

Finds the last character equal to one of characters in the given character sequence. The exact search algorithm is not specified. The search considers only the range [​0​, pos]. If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.

Parameters

str	The string identifying characters to search for.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in str.

find_last_of() [2/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_last_of ( const basic_string_builder< char_t, traits_t, allocator_t > & str, size_type pos ) const

inline

Finds the last character equal to one of characters in the given character sequence. The exact search algorithm is not specified. The search considers only the range [​0​, pos]. If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.

Parameters

str	The string identifying characters to search for.
pos	The position at which to begin searching.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in str.

find_last_of() [3/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_last_of ( const_pointer s, size_type pos, size_type count ) const

inline

Finds the last character equal to one of characters in the given character sequence. The exact search algorithm is not specified. The search considers only the range [​0​, pos]. If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.

Parameters

s	The pointer to a character string identifying characters to search for.
pos	The position at which to begin searching.
count	The length of character string identifying characters to search for.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in the range [s, s + count). This range can include null characters.

If [s, s + count) is not a valid range, the behavior is undefined.

find_last_of() [4/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_last_of ( const_pointer s ) const

inline

Finds the last character equal to one of characters in the given character sequence. The exact search algorithm is not specified. The search considers only the range [​0​, pos]. If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.

Parameters

s	The pointer to a character string identifying characters to search for.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in character string pointed to by s. The length of the string is determined by the first null character using traits_t::length(s).

If [s, s + traits_t::length(s)) is not a valid range, the behavior is undefined.

find_last_of() [5/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_last_of ( const_pointer s, size_type pos ) const

inline

Finds the last character equal to one of characters in the given character sequence. The exact search algorithm is not specified. The search considers only the range [​0​, pos]. If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.

Parameters

s	The pointer to a character string identifying characters to search for.
pos	The position at which to begin searching.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in character string pointed to by s. The length of the string is determined by the first null character using traits_t::length(s).

If [s, s + traits_t::length(s)) is not a valid range, the behavior is undefined.

find_last_of() [6/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_last_of ( value_type ch ) const

inline

Finds the last character equal to one of characters in the given character sequence. The exact search algorithm is not specified. The search considers only the range [​0​, pos]. If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.

Parameters

ch	The character to search for.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to ch.

find_last_of() [7/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_last_of ( value_type ch, size_type pos ) const

inline

Finds the last character equal to one of characters in the given character sequence. The exact search algorithm is not specified. The search considers only the range [​0​, pos]. If none of the characters in the given character sequence is present in the range, xtd::text::basic_string_builder::npos will be returned.

Parameters

ch	The character to search for.
pos	The position at which to begin searching.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to ch.

find_last_not_of() [1/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_last_not_of ( const basic_string_builder< char_t, traits_t, allocator_t > & str ) const

inline

Finds the last character equal to none of the characters in the given character sequence. The search considers only the range [​0​, pos]. If all characters in the range can be found in the given character sequence,xtd::text::basic_string_builder::npos will be returned.

Parameters

str	The string identifying characters to search for.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in str.

find_last_not_of() [2/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_last_not_of ( const basic_string_builder< char_t, traits_t, allocator_t > & str, size_type pos ) const

inline

Finds the last character equal to none of the characters in the given character sequence. The search considers only the range [​0​, pos]. If all characters in the range can be found in the given character sequence,xtd::text::basic_string_builder::npos will be returned.

Parameters

str	The string identifying characters to search for.
pos	The position at which to begin searching.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in str.

find_last_not_of() [3/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_last_not_of ( const_pointer s, size_type pos, size_type count ) const

inline

Finds the last character equal to none of the characters in the given character sequence. The search considers only the range [​0​, pos]. If all characters in the range can be found in the given character sequence,xtd::text::basic_string_builder::npos will be returned.

Parameters

s	The pointer to a character string identifying characters to search for.
pos	The position at which to begin searching.
count	The length of character string identifying characters to search for.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in the range [s, s + count). This range can include null characters.

If [s, s + count) is not a valid range, the behavior is undefined.

find_last_not_of() [4/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_last_not_of ( const_pointer s ) const

inline

Finds the last character equal to none of the characters in the given character sequence. The search considers only the range [​0​, pos]. If all characters in the range can be found in the given character sequence,xtd::text::basic_string_builder::npos will be returned.

Parameters

s	The pointer to a character string identifying characters to search for.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in character string pointed to by s. The length of the string is determined by the first null character using traits_t::length(s).

If [s, s + traits_t::length(s)) is not a valid range, the behavior is undefined.

find_last_not_of() [5/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_last_not_of ( const_pointer s, size_type pos ) const

inline

Finds the last character equal to none of the characters in the given character sequence. The search considers only the range [​0​, pos]. If all characters in the range can be found in the given character sequence,xtd::text::basic_string_builder::npos will be returned.

Parameters

s	The pointer to a character string identifying characters to search for.
pos	The position at which to begin searching.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to one of the characters in character string pointed to by s. The length of the string is determined by the first null character using traits_t::length(s).

If [s, s + traits_t::length(s)) is not a valid range, the behavior is undefined.

find_last_not_of() [6/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_last_not_of ( value_type ch ) const

inline

Finds the last character equal to none of the characters in the given character sequence. The search considers only the range [​0​, pos]. If all characters in the range can be found in the given character sequence,xtd::text::basic_string_builder::npos will be returned.

Parameters

ch	The character to search for.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to ch.

find_last_not_of() [7/7]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::find_last_not_of ( value_type ch, size_type pos ) const

inline

Finds the last character equal to none of the characters in the given character sequence. The search considers only the range [​0​, pos]. If all characters in the range can be found in the given character sequence,xtd::text::basic_string_builder::npos will be returned.

Parameters

ch	The character to search for.
pos	The position at which to begin searching.

Returns

Position of the found character or xtd::text::basic_string_builder::npos if no such character is found.

Remarks

Finds the first character equal to ch.

get_allocator()

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

allocator_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::get_allocator ( ) const

inline

Returns the allocator associated with the string.

Returns

The associated allocator.

get_base_type()

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

virtual const base_type & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::get_base_type ( ) const

inlinevirtualnoexcept

Returns the underlying base type.

Returns

The underlying base type.

get_hash_code()

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

xtd::size xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::get_hash_code ( ) const

inlineoverridevirtualnoexcept

Returns the hash code for this basic_string_builder.

Returns

A hash code.

Reimplemented from xtd::object.

insert() [1/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, const xtd::basic_string< char_t > & value )

inline

Inserts a string into this instance at the specified character position.

Parameters

index	The position in this instance where insertion begins.
value	The string to insert.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Existing characters are shifted to make room for the new text. The capacity is adjusted as needed.

This instance of xtd::text::basic_string_builder is not changed if value is empty (its length is zero).

Notes to Callers

Calls to this method threw an xtd::argument_out_of_range_exception if inserting value would cause the object's total length to exceed xtd::text::basic_string_builder::max_capacity.

insert() [2/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, const xtd::basic_string< char_t > & value, size_type count )

inline

Inserts one or more copies of a specified string into this instance at the specified character position.

Parameters

index	The position in this instance where insertion begins.
value	The string to insert.
count	The number of times to insert value.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Existing characters are shifted to make room for the new text. The capacity is adjusted as needed.

This instance of xtd::text::basic_string_builder is not changed if value is empty (its length is zero).

Notes to Callers

Calls to this method threw an xtd::argument_out_of_range_exception if inserting value would cause the object's total length to exceed xtd::text::basic_string_builder::max_capacity.

insert() [3/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, xtd::boolean value )

inline

Inserts the string representation of a boolean value into this instance at the specified character position.

Parameters

index	The position in this instance where insertion begins.
value	The value to insert.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Existing characters are shifted to make room for the new text. The capacity is adjusted as needed.

This instance of xtd::text::basic_string_builder is not changed if value is empty (its length is zero).

Notes to Callers

Calls to this method threw an xtd::argument_out_of_range_exception if inserting value would cause the object's total length to exceed xtd::text::basic_string_builder::max_capacity.

insert() [4/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, xtd::byte value )

inline

Inserts the string representation of a specified 8-bit unsigned integer into this instance at the specified character position.

Parameters

index	The position in this instance where insertion begins.
value	The value to insert.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Existing characters are shifted to make room for the new text. The capacity is adjusted as needed.

This instance of xtd::text::basic_string_builder is not changed if value is empty (its length is zero).

Notes to Callers

Calls to this method threw an xtd::argument_out_of_range_exception if inserting value would cause the object's total length to exceed xtd::text::basic_string_builder::max_capacity.

insert() [5/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, xtd::decimal value )

inline

Inserts the string representation of a specified 8decimal into this instance at the specified character position.

Parameters

index	The position in this instance where insertion begins.
value	The value to insert.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Existing characters are shifted to make room for the new text. The capacity is adjusted as needed.

This instance of xtd::text::basic_string_builder is not changed if value is empty (its length is zero).

Notes to Callers

Calls to this method threw an xtd::argument_out_of_range_exception if inserting value would cause the object's total length to exceed xtd::text::basic_string_builder::max_capacity.

insert() [6/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, double value )

inline

Inserts the string representation of a specified double into this instance at the specified character position.

Parameters

index	The position in this instance where insertion begins.
value	The value to insert.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Existing characters are shifted to make room for the new text. The capacity is adjusted as needed.

This instance of xtd::text::basic_string_builder is not changed if value is empty (its length is zero).

Notes to Callers

Calls to this method threw an xtd::argument_out_of_range_exception if inserting value would cause the object's total length to exceed xtd::text::basic_string_builder::max_capacity.

insert() [7/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, xtd::single value )

inline

Inserts the string representation of a specified single into this instance at the specified character position.

Parameters

index	The position in this instance where insertion begins.
value	The value to insert.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Existing characters are shifted to make room for the new text. The capacity is adjusted as needed.

This instance of xtd::text::basic_string_builder is not changed if value is empty (its length is zero).

Notes to Callers

Calls to this method threw an xtd::argument_out_of_range_exception if inserting value would cause the object's total length to exceed xtd::text::basic_string_builder::max_capacity.

insert() [8/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, xtd::int16 value )

inline

Inserts the string representation of a specified 16-bit signed integer into this instance at the specified character position.

Parameters

index	The position in this instance where insertion begins.
value	The value to insert.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Existing characters are shifted to make room for the new text. The capacity is adjusted as needed.

This instance of xtd::text::basic_string_builder is not changed if value is empty (its length is zero).

Notes to Callers

Calls to this method threw an xtd::argument_out_of_range_exception if inserting value would cause the object's total length to exceed xtd::text::basic_string_builder::max_capacity.

insert() [9/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, xtd::int32 value )

inline

Inserts the string representation of a specified 32-bit signed integer into this instance at the specified character position.

Parameters

index	The position in this instance where insertion begins.
value	The value to insert.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Existing characters are shifted to make room for the new text. The capacity is adjusted as needed.

This instance of xtd::text::basic_string_builder is not changed if value is empty (its length is zero).

Notes to Callers

Calls to this method threw an xtd::argument_out_of_range_exception if inserting value would cause the object's total length to exceed xtd::text::basic_string_builder::max_capacity.

insert() [10/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, xtd::int64 value )

inline

Inserts the string representation of a specified 64-bit signed integer into this instance at the specified character position.

Parameters

index	The position in this instance where insertion begins.
value	The value to insert.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Existing characters are shifted to make room for the new text. The capacity is adjusted as needed.

This instance of xtd::text::basic_string_builder is not changed if value is empty (its length is zero).

Notes to Callers

Calls to this method threw an xtd::argument_out_of_range_exception if inserting value would cause the object's total length to exceed xtd::text::basic_string_builder::max_capacity.

insert() [11/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, xtd::sbyte value )

inline

Inserts the string representation of a specified 8-bit signed integer into this instance at the specified character position.

Parameters

index	The position in this instance where insertion begins.
value	The value to insert.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Existing characters are shifted to make room for the new text. The capacity is adjusted as needed.

This instance of xtd::text::basic_string_builder is not changed if value is empty (its length is zero).

Notes to Callers

Calls to this method threw an xtd::argument_out_of_range_exception if inserting value would cause the object's total length to exceed xtd::text::basic_string_builder::max_capacity.

insert() [12/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, xtd::uint16 value )

inline

Inserts the string representation of a specified 16-bit unsigned integer into this instance at the specified character position.

Parameters

index	The position in this instance where insertion begins.
value	The value to insert.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Existing characters are shifted to make room for the new text. The capacity is adjusted as needed.

This instance of xtd::text::basic_string_builder is not changed if value is empty (its length is zero).

Notes to Callers

Calls to this method threw an xtd::argument_out_of_range_exception if inserting value would cause the object's total length to exceed xtd::text::basic_string_builder::max_capacity.

insert() [13/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, xtd::uint32 value )

inline

Inserts the string representation of a specified 32-bit unsigned integer into this instance at the specified character position.

Parameters

index	The position in this instance where insertion begins.
value	The value to insert.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Existing characters are shifted to make room for the new text. The capacity is adjusted as needed.

This instance of xtd::text::basic_string_builder is not changed if value is empty (its length is zero).

Notes to Callers

Calls to this method threw an xtd::argument_out_of_range_exception if inserting value would cause the object's total length to exceed xtd::text::basic_string_builder::max_capacity.

insert() [14/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, xtd::uint64 value )

inline

Inserts the string representation of a specified 64-bit unsigned integer into this instance at the specified character position.

Parameters

index	The position in this instance where insertion begins.
value	The value to insert.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Existing characters are shifted to make room for the new text. The capacity is adjusted as needed.

This instance of xtd::text::basic_string_builder is not changed if value is empty (its length is zero).

Notes to Callers

Calls to this method threw an xtd::argument_out_of_range_exception if inserting value would cause the object's total length to exceed xtd::text::basic_string_builder::max_capacity.

insert() [15/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, value_type value )

inline

Inserts the string representation of a specified Unicode character into this instance at the specified character position.

Parameters

index	The position in this instance where insertion begins.
value	The value to insert.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Existing characters are shifted to make room for the new text. The capacity is adjusted as needed.

This instance of xtd::text::basic_string_builder is not changed if value is empty (its length is zero).

Notes to Callers

Calls to this method threw an xtd::argument_out_of_range_exception if inserting value would cause the object's total length to exceed xtd::text::basic_string_builder::max_capacity.

insert() [16/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, value_type value, size_type repeat_count )

inline

Inserts a specified number of copies of the string representation of a Unicode character to this instance at the specified character position.

Parameters

index	The position in this instance where insertion begins.
value	The character to insert.
repeat_count	The number of times to append value.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Existing characters are shifted to make room for the new text. The capacity is adjusted as needed.

This instance of xtd::text::basic_string_builder is not changed if value is empty (its length is zero).

Notes to Callers

Calls to this method threw an xtd::argument_out_of_range_exception if inserting value would cause the object's total length to exceed xtd::text::basic_string_builder::max_capacity.

insert() [17/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

template<class object_t>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, object_t value )

inline

Inserts the string representation of a specified object into this instance at the specified character position.

Template Parameters

object_t

The type of object to insert.

Parameters

index	The position in this instance where insertion begins.
value	The value to insert.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Existing characters are shifted to make room for the new text. The capacity is adjusted as needed.

This instance of xtd::text::basic_string_builder is not changed if value is empty (its length is zero).

Notes to Callers

Calls to this method threw an xtd::argument_out_of_range_exception if inserting value would cause the object's total length to exceed xtd::text::basic_string_builder::max_capacity.

insert() [18/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, size_type count, value_type ch )

inline

Inserts characters into the string.

Parameters

index	The position at which the content will be inserted.
count	The number of characters to insert.
ch	The character to insert.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Inserts count copies of character ch at the position index.

insert() [19/19]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::insert ( size_type index, const basic_string_builder< char_t, traits_t, allocator_t > & str, size_type s_index, size_type count )

inline

Inserts characters into the string.

Parameters

index	The position at which the content will be inserted.
s	The pointer to the character string to insert.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Inserts null-terminated character string pointed to by s at the position index. The length of the string is determined by the first null character using traits_t::length(s). basic_string_builder& insert(size_type index, const_pointer s) {return insert(index, basic_string_builder(s));} / @brief Inserts characters into the string. / @param index The position at which the content will be inserted. / @param s The pointer to the character string to insert. / @param count The number of characters to insert. / @return A reference to this instance after the insert operation has completed. / @exception xtd::argument_out_of_range_exceptionindexis greater than the length of this instance.<rr>-or-<br>Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / @remarks Inserts the characters in the range [s,s + count) at the positionindex. The range can contain null characters. basic_string_builder& insert(size_type index, const_pointer s, size_type count) {return insert(index, basic_string_builder(s, count));} / @brief Inserts characters into the string. / @param index The position at which the content will be inserted. / @param str The string to insert. / @return A reference to this instance after the insert operation has completed. / @exception xtd::argument_out_of_range_exceptionindexis greater than the length of this instance.<rr>-or-<br>Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / @remarks Inserts stringstrat the positionindex. basic_string_builder& insert(size_type index, const basic_string_builder& str) {return insert(index, str, 0, str.length());} / @brief Inserts characters into the string. / @param index The position at which the content will be inserted. / @param str The string to insert. / @param s_index The position of the first character in str to insert. / @param count The number of characters to insert. / @return A reference to this instance after the insert operation has completed. / @exception xtd::argument_out_of_range_exceptionindexis greater than the length of this instance.<rr>-or-<br>Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / @remarks Inserts a string, obtained bystr.substr(s_index, count)at the positionindex.

replace() [1/8]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::replace ( const xtd::basic_string< char_t > & old_value, const xtd::basic_string< char_t > & new_value )

inlinenoexcept

Inserts characters into the string.

Parameters

index	The position at which the content will be inserted.
str	The string to insert.
s_index	The position of the first character in str to insert.

Returns

A reference to this instance after the insert operation has completed.

Exceptions

xtd::argument_out_of_range_exception

`index` is greater than the length of this instance.<rr>-or- Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity.

Remarks

Inserts a string, obtained by str.substr(s_index, str.length()) at the position index. 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);} / @brief Inserts characters into the string. / @param pos The iterator before which the characters will be inserted. / @param ch The character to insert. / @return An iterator which refers to the copy of the first inserted character orposif no characters were inserted (count == 0orfirst == lastorilist.size() == 0) / @exception xtd::argument_out_of_range_exceptionposis greater than the length of this instance.<rr>-or-<br>Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / @remarks Inserts characterchbefore the character pointed bypos. iterator insert(const_iterator pos, value_type ch) {return insert(pos, 1, ch);} / @brief Inserts characters into the string. / @param pos The iterator before which the characters will be inserted. / @param count The number of characters to insert. / @param ch The character to insert. / @return An iterator which refers to the copy of the first inserted character orposif no characters were inserted (count == 0orfirst == lastorilist.size() == 0) / @exception xtd::argument_out_of_range_exceptionposis greater than the length of this instance.<rr>-or-<br>Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / @remarks Insertscountcopies of characterchbefore the element (if any) pointed bypos. iterator insert(const_iterator pos, size_type count, value_type ch ) { if (static_cast<size_type>(std::distance(cbegin(), pos)) > 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); return chars_.insert(pos, count, ch); } / @brief Inserts characters into the string. / @param pos The iterator before which the characters will be inserted. / @param first The firs position of range defining characters to insert. / @param last The last position of range defining characters to insert. / @return An iterator which refers to the copy of the first inserted character orposif no characters were inserted (count == 0orfirst == lastorilist.size() == 0) / @exception xtd::argument_out_of_range_exceptionposis greater than the length of this instance.<rr>-or-<br>Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / @remarks Inserts characters from the range [first,last) before the element (if any) pointed bypos, as if byinsert(pos - begin(), basic_string(first, last, get_allocator())). / @remarks This overload does not participate in overload resolution if input_iterator_t does not satisfy [LegacyInputIterator](https://en.cppreference.com/w/cpp/named_req/InputIterator). template<class 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()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range); if (length() + std::distance(first, last) > max_capacity()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range); return chars_.insert(pos, first, last); } / @brief Inserts characters into the string. / @param pos The iterator before which the characters will be inserted. / @param ilist The [std::initializer_list](https://en.cppreference.com/w/cpp/utility/initializer_list) to insert the characters from / @return An iterator which refers to the copy of the first inserted character orposif no characters were inserted (count == 0orfirst == lastorilist.size() == 0) / @exception xtd::argument_out_of_range_exceptionposis greater than the length of this instance.<rr>-or-<br>Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / @remarks Inserts elements from initializer listilistbefore the element (if any) pointed bypos`. iterator insert(const_iterator pos, std::initializer_list<value_type> ilist) { if (static_cast<size_type>(std::distance(cbegin(), pos)) > length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range); return chars_.insert(pos, ilist); }

/ Removes the last character from the string. /

Remarks

Equivalent to erase(end() - 1). The behavior is undefined if the string is empty. void pop_back() {chars_.pop_back();}

/ Appends the given character ch to the end of the string. /

Parameters

ch	The character to append. void push_back(value_type ch) {chars_.push_back(ch);}

/ Removes the specified range of characters from this instance. /

Parameters

start_index	The zero-based position in this instance where removal begins. /
length	The number of characters to remove. /

Returns

A reference to this instance after the excise operation has completed. /

Exceptions

xtd::argument_out_of_range_exception

If `start_index` + `length` is greater than the length of this instance. /

Remarks

The current method removes the specified range of characters from the current instance. The characters at (start_index + length) are moved to start_index, and the string value of the current instance is shortened by length. The capacity of the current instance is unaffected. /

Warning

The xtd::text::basic_string_builder::remove method modifies the value of the current xtd::text::basic_string_builder instance and returns that instance. It does not create and return a new xtd::text::basic_string_builder object. basic_string_builder& remove(size_type start_index, size_type length) {return erase(start_index, length);}

/ Replaces all occurrences of a specified character in this instance with another specified character. /

Parameters

old_char	The character to replace. /
new_char	The character that replaces old_char. /

Returns

A reference to this instance with old_char replaced by new_char. /

Remarks

This method performs an ordinal, case-sensitive comparison to identify occurrences of old_char in the current instance. The size of the current xtd::text::basic_string_builder instance is unchanged after the replacement. basic_string_builder& replace(value_type old_char, value_type new_char) noexcept {return replace(old_char, new_char, 0, length());} / Replaces, within a substring of this instance, all occurrences of a specified character with another specified character. /

Parameters

old_char	The character to replace. /
new_char	The character that replaces old_char. /
start_index	The position in this instance where the substring begins. /
count	The length of the substring. /

Returns

A reference to this instance with old_char replaced by new_char in the range from start_ index to start_index + count - 1. /

Remarks

This method performs an ordinal, case-sensitive comparison to identify occurrences of old_char in the current instance. The size of the current xtd::text::basic_string_builder object is unchanged after the replacement. 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);} / Replaces all occurrences of a specified string in this instance with another specified string. /

Parameters

old_value

The string to replace. /

new_value

The string that replaces 'old_value. @return A reference to this instance with all instances ofold_valuereplaced bynew_value. @exception xtd::argument_out_of_range_exception Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. @remarks This method performs an ordinal, case-sensitive comparison to identify occurrences ofold_valuein the current instance. Ifnew_valueis xtd::basic_string::empty_string, all occurrences ofold_value` are removed.

replace() [2/8]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::replace ( const_iterator first, const_iterator last, const basic_string_builder< char_t, traits_t, allocator_t > & str )

inline

Replaces, within a substring of this instance, all occurrences of a specified string with another specified string.

Parameters

old_value

The string to replace.

new_value

The string that replaces 'old_value. / @param start_index The position in this instance where the substring begins. / @param count The length of the substring. / @return A reference to this instance with all instances ofold_valuereplaced bynew_valuein the range fromstart_indextostart_index+count- 1. / @exception xtd::argument_out_of_range_exceptionstart_indexpluscountindicates a character position not within this instance.<br>-or-<br>Enlarging the value of this instance would exceed xtd::text::basic_string_builder::max_capacity. / @remarks This method performs an ordinal, case-sensitive comparison to identify occurrences ofold_valuein the substring of this current instance. Ifnew_valueis xtd::basic_string::empty_string, all occurrences ofold_value` are removed. 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()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range); 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; }

/ Replaces the characters in the range [begin() + pos, begin() + std::min(pos + count, size())) or [first, last) with given characters. /

Parameters

pos	The start of the substring that is going to be replaced. /
count	The length of the substring that is going to be replaced. /
str	The string to use for replacement. /

Returns

This current instance of xtd::text::basic_string_builder. /

Remarks

Those characters are replaced with str. basic_string_builder& replace(size_type pos, size_type count, const basic_string_builder& str) { 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 *this; } / Replaces the characters in the range [begin() + pos, begin() + std::min(pos + count, size())) or [first, last) with given characters. /

Parameters

first	The first itrator of range of characters that is going to be replaced. /
last	The last itrator of range of characters that is going to be replaced. /
str	The string to use for replacement. /

Returns

This current instance of xtd::text::basic_string_builder. /

Remarks

Those characters are replaced with str. /

If [begin(), first) or [first, last`) is not a valid range, the behavior is undefined.

replace() [3/8]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::replace ( size_type pos, size_type count, const basic_string_builder< char_t, traits_t, allocator_t > & str, size_type pos2 )

inline

Replaces the characters in the range [begin() + pos, begin() + std::min(pos + count, size())) or [first, last) with given characters.

Parameters

pos	The start of the substring that is going to be replaced.
count	The length of the substring that is going to be replaced.
str	The string to use for replacement.
pos2	The start of the substring to replace with.

Returns

This current instance of xtd::text::basic_string_builder.

Remarks

Those characters are replaced with a substring [pos2, std::min(pos2 + count2, str.size())) of str.

replace() [4/8]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::replace ( size_type pos, size_type count, const basic_string_builder< char_t, traits_t, allocator_t > & str, size_type pos2, size_type count2 )

inline

Replaces the characters in the range [begin() + pos, begin() + std::min(pos + count, size())) or [first, last) with given characters.

Parameters

pos	The start of the substring that is going to be replaced.
count	The length of the substring that is going to be replaced.
str	The string to use for replacement.
pos2	The start of the substring to replace with.
count2	The number of characters to replace with.

Returns

This current instance of xtd::text::basic_string_builder.

Remarks

Those characters are replaced with a substring [pos2, std::min(pos2 + count2, str.size())) of str.

replace() [5/8]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::replace ( size_type pos, size_type count, const_pointer cstr, size_type count2 )

inline

Replaces the characters in the range [begin() + pos, begin() + std::min(pos + count, size())) or [first, last) with given characters.

Parameters

pos	The start of the substring that is going to be replaced.
count	The length of the substring that is going to be replaced.
cstr	The pointer to the character string to use for replacement.

Returns

This current instance of xtd::text::basic_string_builder.

Remarks

Those characters are replaced with the characters in the range [cstr, cstr + count2).

If [cstr, cstr + count2) is not a valid range, the behavior is undefined.

replace() [6/8]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::replace ( const_iterator first, const_iterator last, const_pointer cstr )

inline

Replaces the characters in the range [begin() + pos, begin() + std::min(pos + count, size())) or [first, last) with given characters.

Parameters

first	The first itrator of range of characters that is going to be replaced.
last	The last itrator of range of characters that is going to be replaced.
cstr	The pointer to the character string to use for replacement.
count2	The number of characters to replace with.

Returns

This current instance of xtd::text::basic_string_builder.

Remarks

Those characters are replaced with the characters in the range [cstr, cstr + count2).

If [cstr, cstr + count2) is not a valid range, the behavior is undefined.

If [begin(), first) or [first, last) is not a valid range, the behavior is undefined. basic_string_builder& replace(const_iterator first, const_iterator last, const_pointer cstr, size_type count2) { chars_.replace(first, last, cstr, count2); return *this; } / @brief Replaces the characters in the range [begin() + pos,begin() + std::min(pos + count, size())) or [first,last) with given characters. / @param pos The start of the substring that is going to be replaced. / @param count The length of the substring that is going to be replaced. / @param cstr The pointer to the character string to use for replacement. / @return This current instance of xtd::text::basic_string_builder. / @remarks Those characters are replaced with the characters in the range [cstr,cstr + Traits::length(cstr)). basic_string_builder& replace(size_type pos, size_type count, const_pointer cstr) { chars_.replace(pos, count, cstr); return *this; } / @brief Replaces the characters in the range [begin() + pos,begin() + std::min(pos + count, size())) or [first,last) with given characters. / @param first The first itrator of range of characters that is going to be replaced. / @param last The last itrator of range of characters that is going to be replaced. / @return This current instance of xtd::text::basic_string_builder. / @remarks Those characters are replaced with the characters in the range [cstr,cstr + Traits::length(cstr)). / @remarks If [begin(),first) or [first, last) is not a valid range, the behavior is undefined.

replace() [7/8]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::replace ( size_type pos, size_type count, size_type count2, value_type ch )

inline

Replaces the characters in the range [begin() + pos, begin() + std::min(pos + count, size())) or [first, last) with given characters.

Parameters

pos	The start of the substring that is going to be replaced.
count	The length of the substring that is going to be replaced.
count2	The number of characters to replace with.

Returns

This current instance of xtd::text::basic_string_builder.

Remarks

Those characters are replaced with count2 copies of ch.

replace() [8/8]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

template<class input_iterator_t>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::replace ( const_iterator first, const_iterator last, input_iterator_t first2, input_iterator_t last2 )

inline

Replaces the characters in the range [begin() + pos, begin() + std::min(pos + count, size())) or [first, last) with given characters.

Parameters

first	The first itrator of range of characters that is going to be replaced.
last	The last itrator of range of characters that is going to be replaced.
count2	The number of characters to replace with.

Returns

This current instance of xtd::text::basic_string_builder.

Remarks

Those characters are replaced with count2 copies of ch.

If [begin(), first) or [first, last) is not a valid range, the behavior is undefined. basic_string_builder& replace(const_iterator first, const_iterator last, size_type count2, value_type ch) { chars_.replace(first, last, count2, ch); return *this; } / @brief Replaces the characters in the range [begin() + pos,begin() + std::min(pos + count, size())) or [first,last) with given characters. / @param first The first itrator of range of characters that is going to be replaced. / @param last The last itrator of range of characters that is going to be replaced. / @param first2 The first itrator of range of characters to use for replacement. / @param last2 The last itrator of range of characters to use for replacement. / @return This current instance of xtd::text::basic_string_builder. / @remarks Those characters are replaced with the characters in the range [first2,last2) as if byreplace(first, last, basic_string(first2, last2, get_allocator())). / @remarks If [begin(),first) or [first, last) is not a valid range, the behavior is undefined.

rfind() [1/5]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::rfind ( const basic_string_builder< char_t, traits_t, allocator_t > & str ) const

inline

Replaces the characters in the range [begin() + pos, begin() + std::min(pos + count, size())) or [first, last) with given characters.

Parameters

first	The first itrator of range of characters that is going to be replaced.
last	The last itrator of range of characters that is going to be replaced.
ilist	The initializer list with the characters to use for replacement.

Returns

This current instance of xtd::text::basic_string_builder.

Remarks

Those characters are replaced with the characters in ilist.

If [begin(), first) or [first, last`) is not a valid range, the behavior is undefined. basic_string_builder& replace(const_iterator first, const_iterator last, std::initializer_list<value_type> ilist) { chars_.replace(first, last, ilist); return *this; }

/ Informs a xtd::text::basic_string_builder object of a planned change in size, so that it can manage the storage allocation appropriately /

Parameters

new_cap

The new capacity of the string. /

Remarks

If new_cap is greater than the current capacity(), new storage is allocated, and capacity() is made equal or greater than new_cap. /

If new_cap is less than or equal to the current capacity(), there is no effect. /

If a capacity change takes place, all iterators and references, including the past-the-end iterator, are invalidated. void reserve(size_type new_cap) { if (new_cap > max_capacity_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);; if (new_cap <= capacity()) return; chars_.reserve(new_cap); }

/ Resizes the string to contain count characters. /

Parameters

count

The new size of the string. /

Remarks

If the current size is less than count, additional characters are appended: /

Initializes appended characters to value_type() ('\0' if value_type is char). void resize(size_type count) {chars_.resize(count);} / Resizes the string to contain count characters. /

Parameters

count	The new size of the string. /
ch	The character to initialize the new characters with. /

Remarks

If the current size is less than count, additional characters are appended: /

Initializes appended characters to ch. void resize(size_type count, value_type ch) {chars_.resize(count, ch);}

/ Finds the last substring that is equal to the given character sequence. The search begins at xtd::text::basic_string_builder::nposand proceeds from right to left (thus, the found substring, if any, cannot begin in a position following xtd::text::basic_string_builder::npos). If xtd::text::basic_string_builder::npos or any value not smaller than xtd::text::basic_string_builder::size() - 1 is passed as xtd::text::basic_string_builder::npos, the whole string will be searched. @return Position of the first character of the found substring or xtd::text::basic_string_builder::npos if no such substring is found. @remarks Finds the first substring equal tostr`.

rfind() [2/5]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::rfind ( const basic_string_builder< char_t, traits_t, allocator_t > & str, size_type pos ) const

inline

Finds the last substring that is equal to the given character sequence. The search begins at pos and proceeds from right to left (thus, the found substring, if any, cannot begin in a position following pos). If xtd::text::basic_string_builder::npos or any value not smaller than xtd::text::basic_string_builder::size() - 1 is passed as pos, the whole string will be searched.

Parameters

str	The string to search for.
pos	The position at which to start the search

Returns

Position of the first character of the found substring or xtd::text::basic_string_builder::npos if no such substring is found.

Remarks

Finds the first substring equal to str.

rfind() [3/5]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::rfind ( const_pointer s, size_type pos, size_type count ) const

inline

Finds the last substring that is equal to the given character sequence. The search begins at pos and proceeds from right to left (thus, the found substring, if any, cannot begin in a position following pos). If xtd::text::basic_string_builder::npos or any value not smaller than xtd::text::basic_string_builder::size() - 1 is passed as pos, the whole string will be searched.

Parameters

str	The string to search for.
pos	The position at which to start the search
count	The length of substring to search for.

Returns

Position of the first character of the found substring or xtd::text::basic_string_builder::npos if no such substring is found.

Remarks

Finds the first substring equal to the range [s, s + count).

This range may contain null characters. If [s, s + count) is not a valid range, the behavior is undefined.

rfind() [4/5]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::rfind ( value_type ch ) const

inline

Finds the last substring that is equal to the given character sequence. The search begins at xtd::text::basic_string_builder::nposand proceeds from right to left (thus, the found substring, if any, cannot begin in a position following xtd::text::basic_string_builder::npos). If xtd::text::basic_string_builder::npos or any value not smaller than xtd::text::basic_string_builder::size() - 1 is passed as xtd::text::basic_string_builder::npos, the whole string will be searched. / @param s The pointer to a character string to search for. / @return Position of the first character of the found substring or xtd::text::basic_string_builder::npos if no such substring is found. / @remarks Finds the first substring equal to the character string pointed to bys. The length of the string is determined by the first null character usingtraits_t::length(s). / @remarks If [s,s + traits_t::length(s)) is not a valid range, the behavior is undefined. size_type rfind(const_pointer s) const {return chars_.rfind(s);} / @brief Finds the last substring that is equal to the given character sequence. The search begins atposand proceeds from right to left (thus, the found substring, if any, cannot begin in a position followingpos). If xtd::text::basic_string_builder::npos or any value not smaller than xtd::text::basic_string_builder::size() - 1 is passed aspos, the whole string will be searched. / @param s The pointer to a character string to search for. / @param pos The position at which to start the search / @return Position of the first character of the found substring or xtd::text::basic_string_builder::npos if no such substring is found. / @remarks Finds the first substring equal to the character string pointed to bys. The length of the string is determined by the first null character usingtraits_t::length(s). / @remarks If [s,s + traits_t::length(s)) is not a valid range, the behavior is undefined. size_type rfind(const_pointer s, size_type pos) const {return chars_.rfind(s, pos);} / @brief Finds the last substring that is equal to the given character sequence. The search begins at xtd::text::basic_string_builder::npos and proceeds from right to left (thus, the found substring, if any, cannot begin in a position following xtd::text::basic_string_builder::npos). If xtd::text::basic_string_builder::npos or any value not smaller than xtd::text::basic_string_builder::size() - 1 is passed as xtd::text::basic_string_builder::npos, the whole string will be searched.

Parameters

ch	The character to search for.

Returns

Position of the first character of the found substring or xtd::text::basic_string_builder::npos if no such substring is found.

Remarks

Finds the first character ch (treated as a single-character substring by the formal rules below).

rfind() [5/5]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

size_type xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::rfind ( value_type ch, size_type pos ) const

inline

Finds the last substring that is equal to the given character sequence. The search begins at pos and proceeds from right to left (thus, the found substring, if any, cannot begin in a position following pos). If xtd::text::basic_string_builder::npos or any value not smaller than xtd::text::basic_string_builder::size() - 1 is passed as pos, the whole string will be searched.

Parameters

ch	The character to search for.
pos	The position at which to start the search

Returns

Position of the first character of the found substring or xtd::text::basic_string_builder::npos if no such substring is found.

Remarks

Finds the first character ch (treated as a single-character substring by the formal rules below).

shrink_to_fit()

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

void xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::shrink_to_fit ( )

inline

Requests the removal of unused capacity.

Remarks

It is a non-binding request to reduce capacity() to size(). It depends on the implementation if the request is fulfilled.

If (and only if) reallocation takes place, all pointers, references, and iterators are invalidated.

substr() [1/3]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::substr ( ) const

inline

Returns a substring [pos, pos + count). If the requested substring extends past the end of the string, i.e. the count is greater than size() - pos (e.g. if count == xtd::text::basic_string_builder::npos), the returned substring is [pos, size()).

Returns

String containing the substring [pos, pos + count) or [pos, size()).

Exceptions

`std::out_of_range`

if `pos > size()`.

Remarks

Equivalent to return basic_string_builder(*this, pos, count);.

substr() [2/3]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::substr ( size_type pos ) const

inline

Returns a substring [pos, pos + count). If the requested substring extends past the end of the string, i.e. the count is greater than size() - pos (e.g. if count == xtd::text::basic_string_builder::npos), the returned substring is [pos, size()).

Parameters

pos	The position of the first character to include.

Returns

String containing the substring [pos, pos + count) or [pos, size()).

Exceptions

`std::out_of_range`

if `pos > size()`.

Remarks

Equivalent to return basic_string_builder(*this, pos, count);.

substr() [3/3]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::substr ( size_type pos, size_type count ) const

inline

Returns a substring [pos, pos + count). If the requested substring extends past the end of the string, i.e. the count is greater than size() - pos (e.g. if count == xtd::text::basic_string_builder::npos), the returned substring is [pos, size()).

Parameters

pos	The position of the first character to include.
count	The length of the substring.

Returns

String containing the substring [pos, pos + count) or [pos, size()).

Exceptions

`std::out_of_range`

if `pos > size()`.

Remarks

Equivalent to return basic_string_builder(*this, pos, count);.

swap()

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

void xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::swap ( basic_string_builder< char_t, traits_t, allocator_t > & other )

inlinenoexcept

Exchanges the contents of the string with those of other. All iterators and references may be invalidated.

Parameters

other

The string to exchange the contents with.

to_string()

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

xtd::string xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::to_string ( ) const

inlineoverridevirtualnoexcept

Converts the value of this instance to a xtd::text::basic_string_builder <char>.

Returns

The current string.

Todo

Uncomment the folllowing line and remove the next..

Reimplemented from xtd::object.

operator[]() [1/2]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

const_reference xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::operator[] ( xtd::size index ) const

inline

Returns a reference to the character at specified location index.

Parameters

index

The position of the character to return.

Returns

Reference to the requested character.

Exceptions

xtd::index_out_of_range_exception

If `index` is not within the range of the string.

operator[]() [2/2]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

reference xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::operator[] ( xtd::size index )

inline

Returns a reference to the character at specified location index.

Parameters

index

The position of the character to return.

Returns

Reference to the requested character.

Exceptions

xtd::index_out_of_range_exception

If `index` is not within the range of the string.

operator const base_type &()

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::operator const base_type & ( ) const

inlinenoexcept

Returns a reference to the underlying base type.

Returns

Reference to the underlying base type.

operator base_type &()

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::operator base_type & ( )

inlinenoexcept

Returns a reference to the underlying base type.

Returns

Reference to the underlying base type.

operator=() [1/9]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::operator= ( const basic_string_builder< char_t, traits_t, allocator_t > & str )

inlinenoexcept

Copy assignment operator. Replaces the contents with a copy of the contents of str.

Parameters

str	String to use as data source.

Returns

This current instance.

operator=() [2/9]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::operator= ( basic_string_builder< char_t, traits_t, allocator_t > && str )

inlinenoexcept

Move assignment operator. Replaces the contents with those of other using move semantics (i.e. the data in str is moved from str into this string). str is in a valid but unspecified state afterwards.

Parameters

str	String to use as data source.

Returns

This current instance.

operator=() [3/9]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::operator= ( const std::basic_string< value_type > & str )

inlinenoexcept

Copy assignment operator. Replaces the contents with a copy of the contents of str.

Parameters

str	String to use as data source.

Returns

This current instance.

operator=() [4/9]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::operator= ( std::basic_string< value_type > && str )

inlinenoexcept

Copy assignment operator. Replaces the contents with a copy of the contents of str.

Parameters

str	String to use as data source.

Returns

This current instance.

operator=() [5/9]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::operator= ( const xtd::basic_string< value_type > & str )

inlinenoexcept

Copy assignment operator. Replaces the contents with a copy of the contents of str.

Parameters

str	String to use as data source.

Returns

This current instance.

operator=() [6/9]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::operator= ( xtd::basic_string< value_type > && str )

inlinenoexcept

Copy assignment operator. Replaces the contents with a copy of the contents of str.

Parameters

str	String to use as data source.

Returns

This current instance.

operator=() [7/9]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::operator= ( const_pointer str )

inline

Copy assignment operator. Replaces the contents with a copy of the contents of str.

Parameters

str	String litteral pointer to use as data source.

Exceptions

xtd::tring_null_pointer_exception

The `str` is null.

Returns

This current instance.

operator=() [8/9]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::operator= ( value_type character )

inline

Copy assignment operator. Replaces the contents with the specified character.

Parameters

character

The character to use as data source.

Returns

This current instance.

operator=() [9/9]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::operator= ( const std::initializer_list< value_type > & il )

inline

Copy assignment operator. Replaces the contents with a copy of the contents of the specified initializer list.

Parameters

il	The initialiazer list to use as data source.

Returns

This current instance.

operator+=() [1/4]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::operator+= ( const basic_string_builder< char_t, traits_t, allocator_t > & str )

inline

Addition assignment operator. Appends additional characters to the string.

Parameters

str	string to append.

Returns

This current instance with characters added.

operator+=() [2/4]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::operator+= ( basic_string_builder< char_t, traits_t, allocator_t > && str )

inline

Addition assignment operator. Appends additional characters to the string.

Parameters

str	string to append.

Returns

This current instance with characters added.

operator+=() [3/4]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::operator+= ( const_pointer str )

inline

Addition assignment operator. Appends additional characters to the string.

Parameters

str	string to append.

Returns

This current instance with characters added.

operator+=() [4/4]

template<class char_t, class traits_t = std::char_traits<char_t>, class allocator_t = xtd::collections::generic::helpers::allocator<char_t>>

basic_string_builder & xtd::text::basic_string_builder< char_t, traits_t, allocator_t >::operator+= ( value_type ch )

inline

Addition assignment operator. Appends additional characters to the string.

Parameters

ch	Character value to append.

Returns

This current instance with characters added.

---

The documentation for this class was generated from the following file:

• xtd.core/include/xtd/text/basic_string_builder.hpp