typedef Char char_type;

The type of code unit used in the underlying storage.

typedef String string;

The type of the container used as underlying storage.

typedef basic_string_view< char_type > string_view;

The specialization of std::basic_string_view (or boost::basic_string_view in pre-C++17 code) compatible with string.

typedef basic_text_view< Normalization, char_type > text_view;

The specialization of basic_text_view with the same normalization form and underlying code unit type.

basic_text();

Default ctor.

basic_text(basic_text const &) = default;

basic_text(basic_text &&);

basic_text(const_iterator first, const_iterator last);

Constructs a basic_text from a pair of iterators.

basic_text(char_type const * c_str);

Constructs a basic_text from a null-terminated string.

explicit basic_text(text_view tv);

Constructs a basic_text from a text_view.

explicit basic_text(rope_view rv);

Constructs a basic_text from a rope_view.

template<code_unit_range< utf_format > R> explicit basic_text(R const & r);

Constructs a basic_text from a range of char_type.

template<code_unit_iter< utf_format > I, std::sentinel_for< I > S> 
  basic_text(I first, S last);

Constructs a basic_text from a sequence of char_type.

template<grapheme_range_code_unit< utf_format > R> 
  explicit basic_text(R const & r);

Constructs a basic_text from a range of graphemes.

template<grapheme_iter_code_unit< utf_format > I> 
  explicit basic_text(I first, I last);

Constructs a basic_text from a sequence of graphemes.

basic_text & operator=(basic_text const &) = default;

basic_text & operator=(basic_text &&);

basic_text & operator=(char_type const * c_str);

Assignment from a null-terminated string.

basic_text & operator=(string_view sv);

Assignment from a string_view.

basic_text & operator=(text_view tv);

Assignment from a text_view.

basic_text & operator=(rope_view rv);

Assignment from a rope_view.

 BOOST_TEXT_STATIC_ASSERT_NORMALIZATION();

operator text_view() const;

char_type * data();

char_type const * data() const;

char_type const * c_str() const;

const_reference front() const;

const_reference back() const;

reference front();

reference back();

void push_back(grapheme const & g);

template<typename CPIter> void push_back(grapheme_ref< CPIter > g);

void pop_back();

iterator begin();

iterator end();

const_iterator begin() const;

const_iterator end() const;

const_iterator cbegin() const;

const_iterator cend() const;

reverse_iterator rbegin();

reverse_iterator rend();

const_reverse_iterator rbegin() const;

const_reverse_iterator rend() const;

const_reverse_iterator crbegin() const;

const_reverse_iterator crend() const;

bool empty() const;

Returns true iff size() == 0.

size_type storage_code_units() const;

Returns the number of code units controlled by *this, not including the null terminator.

size_type capacity_bytes() const;

Returns the number of bytes of storage currently in use by *this.

size_type distance() const;

Returns the number of graphemes in *this. This operation is O(n).

size_type max_code_units() const;

Returns the maximum size in code units a basic_text can have.

void clear();

Clear.

replace_result< iterator > erase(const_iterator first, const_iterator last);

Erases the portion of *this delimited by [first, last).

replace_result< iterator > erase(const_iterator at);

Erases the grapheme at position at.

replace_result< iterator > 
replace(const_iterator first1, const_iterator last1, const_iterator first2, 
        const_iterator last2);

Replaces the portion of *this delimited by [first1, last1) with the sequence [first2, last2).

replace_result< iterator > 
replace(const_iterator first, const_iterator last, 
        char_type const * new_substr);

Replaces the portion of *this delimited by [first, last) with new_substr.

replace_result< iterator > 
replace(const_iterator first, const_iterator last, string_view new_substr);

Replaves the portion of *this delimited by [first, last) with new_substr.

replace_result< iterator > 
replace(const_iterator first, const_iterator last, rope_view new_substr);

Replaces the portion of *this delimited by [first, last) with new_substr.

template<code_unit_range< utf_format > R> 
  replace_result< iterator > 
  replace(const_iterator first, const_iterator last, R const & r);

Replaces the portion of *this delimited by [first, last) with r.

template<code_unit_iter< utf_format > I> 
  replace_result< iterator > 
  replace(const_iterator first1, const_iterator last1, I first2, I last2);

Replaces the portion of *this delimited by [first1, last1) with [first2, last2).

template<grapheme_range_code_unit< utf_format > R> 
  replace_result< iterator > 
  replace(const_iterator first, const_iterator last, R const & r);

Replaces the portion of *this delimited by [first, last) with r.

template<grapheme_iter_code_unit< utf_format > I> 
  replace_result< iterator > 
  replace(const_iterator first1, const_iterator last1, I first2, I last2);

Replaces the portion of *this delimited by [first1, last1) with [first2, last2).

replace_result< iterator > 
replace(const_iterator first, const_iterator last, grapheme const & g);

Replaces the portion of *this delimited by [first, last) with g.

template<typename CPIter> 
  replace_result< iterator > 
  replace(const_iterator first, const_iterator last, grapheme_ref< CPIter > g);

Replaces the portion of *this delimited by [first, last) with g.

replace_result< iterator > 
insert(const_iterator at, const_iterator first, const_iterator last);

Inserts the sequence [first, last) into *this starting at position at.

template<typename T> auto insert(const_iterator at, T const & x);

Inserts the sequence of char_type from x into *this starting at position at.

template<typename I> auto insert(const_iterator at, I first, I last);

Inserts the sequence [first, last) into *this starting at position at.

void assign(const_iterator first, const_iterator last);

Assigns the sequence [first, last) to *this.

template<typename T> auto assign(T const & x);

Assigns the sequence of char_type from x to *this.

template<typename I> auto assign(I first, I last);

Assigns the sequence [first, last) to *this.

void append(const_iterator first, const_iterator last);

Appends the sequence [first, last) to *this.

template<typename T> auto append(T const & x);

Appends the sequence of char_type from x to *this.

template<typename I> auto append(I first, I last);

Appends the sequence [first, last) to *this.

void reserve(size_type new_size);

Reserves storage enough for a string of at least new_size bytes.

void shrink_to_fit();

Reduces storage used by *this to just the amount necessary to contain size() chars.

void swap(basic_text & rhs);

Swaps *this with rhs.

string extract();

Removes and returns the underlying string from *this.

void replace(string && s);

Replaces the underlying string in *this.

template<typename T> auto operator+=(T const & x);

Appends x to *this. T may be any type for which *this = x is well-formed.

std::ostream & operator<<(std::ostream & os, basic_text const & t);

Stream inserter; performs formatted output, in UTF-8 encoding.

std::wostream & operator<<(std::wostream & os, basic_text const & t);

Stream inserter; performs formatted output, in UTF-16 encoding. Defined on Windows only.

template<typename T> bool operator==(basic_text const & lhs, T const & rhs);

Returns true iff lhs == rhs, where rhs is an object for which lhs = rhs is well-formed.

template<typename T> bool operator==(T const & lhs, basic_text const & rhs);

Returns true iff lhs == rhs, where rhs is an object for which rhs = lhs is well-formed.

template<typename T> bool operator!=(basic_text const & lhs, T const & rhs);

Returns true iff lhs != rhs, where rhs is an object for which lhs = rhs is well-formed.

template<typename T> bool operator!=(T const & lhs, basic_text const & rhs);

Returns true iff lhs != rhs, where rhs is an object for which rhs = lhs is well-formed.

static constexpr nf normalization;

The normalization form used in this basic_text.

static constexpr format utf_format;

The UTF format used in the underlying storage.