Cumulative include for string_algo library

Defines sequence case-conversion algorithms. Algorithms convert each element in the input sequence to the desired case using provided locales.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const RangeT &

An input range

` `const std::locale &std::locale()

A locale used for conversion

`
SequenceT `const SequenceT &` `const std::locale &std::locale()`
Convert to lower case.

Each element of the input sequence is converted to lower case. The result is a copy of the input converted to lower case. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a copy of the input

void `WritableRangeT &

A range

` `const std::locale &std::locale()

a locale used for conversion

` Convert to lower case.

Each element of the input sequence is converted to lower case. The input sequence is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const RangeT &

An input range

` `const std::locale &std::locale()

A locale used for conversion

`
SequenceT `const SequenceT &` `const std::locale &std::locale()`
Convert to upper case.

Each element of the input sequence is converted to upper case. The result is a copy of the input converted to upper case. It is returned as a sequence or copied to the output iterator

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a copy of the input

void `WritableRangeT &

An input range

` `const std::locale &std::locale()

a locale used for conversion

` Convert to upper case.

Each element of the input sequence is converted to upper case. The input sequence is modified in-place.

Classification predicates are included in the library to give some more convenience when using algorithms like `trim()` and `all()`. They wrap functionality of STL classification functions ( e.g. `std::isspace()` ) into generic functors.

unspecified `std::ctype_base::mask

A `std::ctype` category

` `const std::locale &std::locale()

A locale used for classification

` is_classified predicate

Construct the `is_classified` predicate. This predicate holds if the input is of specified `std::ctype` category.

An instance of the `is_classified` predicate

unspecified `const std::locale &std::locale()

A locale used for classification

` is_space predicate

Construct the `is_classified` predicate for the `ctype_base::space` category.

An instance of the `is_classified` predicate

unspecified `const std::locale &std::locale()

A locale used for classification

` is_alnum predicate

Construct the `is_classified` predicate for the `ctype_base::alnum` category.

An instance of the `is_classified` predicate

unspecified `const std::locale &std::locale()

A locale used for classification

` is_alpha predicate

Construct the `is_classified` predicate for the `ctype_base::alpha` category.

An instance of the `is_classified` predicate

unspecified `const std::locale &std::locale()

A locale used for classification

` is_cntrl predicate

Construct the `is_classified` predicate for the `ctype_base::cntrl` category.

An instance of the `is_classified` predicate

unspecified `const std::locale &std::locale()

A locale used for classification

` is_digit predicate

Construct the `is_classified` predicate for the `ctype_base::digit` category.

An instance of the `is_classified` predicate

unspecified `const std::locale &std::locale()

A locale used for classification

` is_graph predicate

Construct the `is_classified` predicate for the `ctype_base::graph` category.

An instance of the `is_classified` predicate

unspecified `const std::locale &std::locale()

A locale used for classification

` is_lower predicate

Construct the `is_classified` predicate for the `ctype_base::lower` category.

An instance of `is_classified` predicate

unspecified `const std::locale &std::locale()

A locale used for classification

` is_print predicate

Construct the `is_classified` predicate for the `ctype_base::print` category.

An instance of the `is_classified` predicate

unspecified `const std::locale &std::locale()

A locale used for classification

` is_punct predicate

Construct the `is_classified` predicate for the `ctype_base::punct` category.

An instance of the `is_classified` predicate

unspecified `const std::locale &std::locale()

A locale used for classification

` is_upper predicate

Construct the `is_classified` predicate for the `ctype_base::upper` category.

An instance of the `is_classified` predicate

unspecified `const std::locale &std::locale()

A locale used for classification

` is_xdigit predicate

Construct the `is_classified` predicate for the `ctype_base::xdigit` category.

An instance of the `is_classified` predicate

unspecified `const RangeT &

A set of characters to be recognized

` is_any_of predicate

Construct the `is_any_of` predicate. The predicate holds if the input is included in the specified set of characters.

An instance of the `is_any_of` predicate

unspecified `CharT

The start of the range

` `CharT

The end of the range

` is_from_range predicate

Construct the `is_from_range` predicate. The predicate holds if the input is included in the specified range. (i.e. From <= Ch <= To )

An instance of the `is_from_range` predicate

unspecified `const predicate_facade< Pred1T > &

The first predicate

` `const predicate_facade< Pred2T > &

The second predicate

` predicate 'and' composition predicate

Construct the `class_and` predicate. This predicate can be used to logically combine two classification predicates. `class_and` holds, if both predicates return true.

An instance of the `class_and` predicate

unspecified `const predicate_facade< Pred1T > &

The first predicate

` `const predicate_facade< Pred2T > &

The second predicate

` predicate 'or' composition predicate

Construct the `class_or` predicate. This predicate can be used to logically combine two classification predicates. `class_or` holds, if one of the predicates return true.

An instance of the `class_or` predicate

unspecified `const predicate_facade< PredT > &

The predicate to be negated

` predicate negation operator

Construct the `class_not` predicate. This predicate represents a negation. `class_or` holds if of the predicates return false.

An instance of the `class_not` predicate

Defines element comparison predicates. Many algorithms in this library can take an additional argument with a predicate used to compare elements. This makes it possible, for instance, to have case insensitive versions of the algorithms.

boost::algorithm::is_equal

is_equal
functor

Standard STL equal_to only handle comparison between arguments of the same type. This is a less restrictive version which wraps operator ==.

bool `const T1 &` `const T2 &` Function operator.

Compare two operands for equality

case insensitive version of `is_equal`

Case insensitive comparison predicate. Comparison is done using specified locales.

bool `const T1 &` `const T2 &` Function operator.

Compare two operands. Case is ignored.

const std::locale &
std::locale()

locales used for comparison

Constructor.

case insensitive version of `is_less`

Case insensitive comparison predicate. Comparison is done using specified locales.

bool `const T1 &` `const T2 &` Function operator.

Compare two operands. Case is ignored.

const std::locale &
std::locale()

locales used for comparison

Constructor.

boost::algorithm::is_less

is_less
functor

Convenient version of standard std::less. Operation is templated, therefore it is not required to specify the exact types upon the construction

bool `const T1 &` `const T2 &` Functor operation.

Compare two operands using > operator

boost::algorithm::is_not_greater

is_not_greater
functor

Convenient version of standard std::not_greater_to. Operation is templated, therefore it is not required to specify the exact types upon the construction

bool `const T1 &` `const T2 &` Functor operation.

Compare two operands using > operator

case insensitive version of `is_not_greater`

Case insensitive comparison predicate. Comparison is done using specified locales.

bool `const T1 &` `const T2 &` Function operator.

Compare two operands. Case is ignored.

const std::locale &
std::locale()

locales used for comparison

Constructor.

Defines concepts used in string_algo library

Finder concept.

Defines the Finder concept. Finder is a functor which selects an arbitrary part of a string. Search is performed on the range specified by starting and ending iterators.

Result of the find operation must be convertible to iterator_range.

void
Formatter concept.

Defines the Formatter concept. Formatter is a functor, which takes a result from a finder operation and transforms it in a specific way.

Result must be a container supported by container_traits, or a reference to it.

void
Compress adjacent tokens.
Do not compress adjacent tokens.
Token compression mode.

Specifies token compression mode for the token_finder.

Defines various erase algorithms. Each algorithm removes part(s) of the input according to a searching criteria.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const RangeT &

An input sequence

` `const iterator_range< typename range_const_iterator< RangeT >::type > &

A range in the input to be removed

`
SequenceT `const SequenceT &` `const iterator_range< typename range_const_iterator< SequenceT >::type > &`
Erase range algorithm.

Remove the given range from the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input sequence

` `const iterator_range< typename range_iterator< SequenceT >::type > &

A range in the input to be removed

` Erase range algorithm.

Remove the given range from the input. The input sequence is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input string

` `const Range2T &

A substring to be searched for

`
SequenceT `const SequenceT &` `const RangeT &`
Erase first algorithm.

Remove the first occurrence of the substring from the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const RangeT &

A substring to be searched for.

` Erase first algorithm.

Remove the first occurrence of the substring from the input. The input sequence is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input string

` `const Range2T &

A substring to be searched for

` `const std::locale &std::locale()

A locale used for case insensitive comparison

`
SequenceT `const SequenceT &` `const RangeT &` `const std::locale &std::locale()`
Erase first algorithm ( case insensitive )

Remove the first occurrence of the substring from the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. Searching is case insensitive.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const RangeT &

A substring to be searched for

` `const std::locale &std::locale()

A locale used for case insensitive comparison

` Erase first algorithm ( case insensitive )

Remove the first occurrence of the substring from the input. The input sequence is modified in-place. Searching is case insensitive.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input string

` `const Range2T &

A substring to be searched for.

`
SequenceT `const SequenceT &` `const RangeT &`
Erase last algorithm.

Remove the last occurrence of the substring from the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const RangeT &

A substring to be searched for

` Erase last algorithm.

Remove the last occurrence of the substring from the input. The input sequence is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input string

` `const Range2T &

A substring to be searched for

` `const std::locale &std::locale()

A locale used for case insensitive comparison

`
SequenceT `const SequenceT &` `const RangeT &` `const std::locale &std::locale()`
Erase last algorithm ( case insensitive )

Remove the last occurrence of the substring from the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. Searching is case insensitive.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const RangeT &

A substring to be searched for

` `const std::locale &std::locale()

A locale used for case insensitive comparison

` Erase last algorithm ( case insensitive )

Remove the last occurrence of the substring from the input. The input sequence is modified in-place. Searching is case insensitive.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input string

` `const Range2T &

A substring to be searched for

` `int

An index of the match to be replaced. The index is 0-based. For negative N, matches are counted from the end of string.

`
SequenceT `const SequenceT &` `const RangeT &` `int`
Erase nth algorithm.

Remove the Nth occurrence of the substring in the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const RangeT &

A substring to be searched for.

` `int

An index of the match to be replaced. The index is 0-based. For negative N, matches are counted from the end of string.

` Erase nth algorithm.

Remove the Nth occurrence of the substring in the input. The input sequence is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input string

` `const Range2T &

A substring to be searched for.

` `int

An index of the match to be replaced. The index is 0-based. For negative N, matches are counted from the end of string.

` `const std::locale &std::locale()

A locale used for case insensitive comparison

`
SequenceT `const SequenceT &` `const RangeT &` `int` `const std::locale &std::locale()`
Erase nth algorithm ( case insensitive )

Remove the Nth occurrence of the substring in the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. Searching is case insensitive.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const RangeT &

A substring to be searched for.

` `int

An index of the match to be replaced. The index is 0-based. For negative N, matches are counted from the end of string.

` `const std::locale &std::locale()

A locale used for case insensitive comparison

` Erase nth algorithm.

Remove the Nth occurrence of the substring in the input. The input sequence is modified in-place. Searching is case insensitive.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input sequence

` `const Range2T &

A substring to be searched for.

`
SequenceT `const SequenceT &` `const RangeT &`
Erase all algorithm.

Remove all the occurrences of the string from the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const RangeT &

A substring to be searched for.

` Erase all algorithm.

Remove all the occurrences of the string from the input. The input sequence is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input string

` `const Range2T &

A substring to be searched for

` `const std::locale &std::locale()

A locale used for case insensitive comparison

`
SequenceT `const SequenceT &` `const RangeT &` `const std::locale &std::locale()`
Erase all algorithm ( case insensitive )

Remove all the occurrences of the string from the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. Searching is case insensitive.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const RangeT &

A substring to be searched for.

` `const std::locale &std::locale()

A locale used for case insensitive comparison

` Erase all algorithm ( case insensitive )

Remove all the occurrences of the string from the input. The input sequence is modified in-place. Searching is case insensitive.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const RangeT &

An input string

` `int

Length of the head. For N>=0, at most N characters are extracted. For N<0, size(Input)-|N| characters are extracted.

`
SequenceT `const SequenceT &` `int`
Erase head algorithm.

Remove the head from the input. The head is a prefix of a sequence of given size. If the sequence is shorter then required, the whole string is considered to be the head. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `int

Length of the head For N>=0, at most N characters are extracted. For N<0, size(Input)-|N| characters are extracted.

` Erase head algorithm.

Remove the head from the input. The head is a prefix of a sequence of given size. If the sequence is shorter then required, the whole string is considered to be the head. The input sequence is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const RangeT &

An input string

` `int

Length of the tail.

`
SequenceT `const SequenceT &` `int`
Erase tail algorithm.

Remove the tail from the input. The tail is a suffix of a sequence of given size. If the sequence is shorter then required, the whole string is considered to be the tail. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

For N>=0, at most N characters are extracted. For N<0, size(Input)-|N| characters are extracted.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `int

Length of the tail For N>=0, at most N characters are extracted. For N<0, size(Input)-|N| characters are extracted.

` Erase tail algorithm.

Remove the tail from the input. The tail is a suffix of a sequence of given size. If the sequence is shorter then required, the whole string is considered to be the tail. The input sequence is modified in-place.

Defines a set of find algorithms. The algorithms are searching for a substring of the input. The result is given as an `iterator_range` delimiting the substring.

iterator_range< typename range_iterator< RangeT >::type > `RangeT &

A string which will be searched.

` `const FinderT &

Finder object used for searching.

` Generic find algorithm.

Search the input using the given finder.

An `iterator_range` delimiting the match. Returned iterator is either `RangeT::iterator` or `RangeT::const_iterator`, depending on the constness of the input parameter.

iterator_range< typename range_iterator< Range1T >::type > `Range1T &

A string which will be searched.

` `const Range2T &

A substring to be searched for.

` Find first algorithm.

Search for the first occurrence of the substring in the input.

This function provides the strong exception-safety guarantee

An `iterator_range` delimiting the match. Returned iterator is either `RangeT::iterator` or `RangeT::const_iterator`, depending on the constness of the input parameter.

iterator_range< typename range_iterator< Range1T >::type > `Range1T &

A string which will be searched.

` `const Range2T &

A substring to be searched for.

` `const std::locale &std::locale()

A locale used for case insensitive comparison

` Find first algorithm ( case insensitive )

Search for the first occurrence of the substring in the input. Searching is case insensitive.

This function provides the strong exception-safety guarantee

An `iterator_range` delimiting the match. Returned iterator is either `Range1T::iterator` or `Range1T::const_iterator`, depending on the constness of the input parameter.

iterator_range< typename range_iterator< Range1T >::type > `Range1T &

A string which will be searched.

` `const Range2T &

A substring to be searched for.

` Find last algorithm.

Search for the last occurrence of the substring in the input.

This function provides the strong exception-safety guarantee

An `iterator_range` delimiting the match. Returned iterator is either `Range1T::iterator` or `Range1T::const_iterator`, depending on the constness of the input parameter.

iterator_range< typename range_iterator< Range1T >::type > `Range1T &

A string which will be searched.

` `const Range2T &

A substring to be searched for.

` `const std::locale &std::locale()

A locale used for case insensitive comparison

` Find last algorithm ( case insensitive )

Search for the last match a string in the input. Searching is case insensitive.

This function provides the strong exception-safety guarantee

An `iterator_range` delimiting the match. Returned iterator is either `Range1T::iterator` or `Range1T::const_iterator`, depending on the constness of the input parameter.

iterator_range< typename range_iterator< Range1T >::type > `Range1T &

A string which will be searched.

` `const Range2T &

A substring to be searched for.

` `int

An index (zero-indexed) of the match to be found. For negative N, the matches are counted from the end of string.

` Find n-th algorithm.

Search for the n-th (zero-indexed) occurrence of the substring in the input.

An `iterator_range` delimiting the match. Returned iterator is either `Range1T::iterator` or `Range1T::const_iterator`, depending on the constness of the input parameter.

iterator_range< typename range_iterator< Range1T >::type > `Range1T &

A string which will be searched.

` `const Range2T &

A substring to be searched for.

` `int

An index (zero-indexed) of the match to be found. For negative N, the matches are counted from the end of string.

` `const std::locale &std::locale()

A locale used for case insensitive comparison

` Find n-th algorithm ( case insensitive ).

Search for the n-th (zero-indexed) occurrence of the substring in the input. Searching is case insensitive.

This function provides the strong exception-safety guarantee

An `iterator_range` delimiting the match. Returned iterator is either `Range1T::iterator` or `Range1T::const_iterator`, depending on the constness of the input parameter.

iterator_range< typename range_iterator< RangeT >::type > `RangeT &

An input string

` `int

Length of the head For N>=0, at most N characters are extracted. For N<0, at most size(Input)-|N| characters are extracted.

` Find head algorithm.

Get the head of the input. Head is a prefix of the string of the given size. If the input is shorter then required, whole input is considered to be the head.

This function provides the strong exception-safety guarantee

An `iterator_range` delimiting the match. Returned iterator is either `Range1T::iterator` or `Range1T::const_iterator`, depending on the constness of the input parameter.

iterator_range< typename range_iterator< RangeT >::type > `RangeT &

An input string

` `int

Length of the tail. For N>=0, at most N characters are extracted. For N<0, at most size(Input)-|N| characters are extracted.

` Find tail algorithm.

Get the tail of the input. Tail is a suffix of the string of the given size. If the input is shorter then required, whole input is considered to be the tail.

This function provides the strong exception-safety guarantee

An `iterator_range` delimiting the match. Returned iterator is either `RangeT::iterator` or `RangeT::const_iterator`, depending on the constness of the input parameter.

iterator_range< typename range_iterator< RangeT >::type > `RangeT &

A input string.

` `PredicateT

A unary predicate to identify a token

` `token_compress_mode_typetoken_compress_off

Enable/Disable compressing of adjacent tokens

` Find token algorithm.

Look for a given token in the string. Token is a character that matches the given predicate. If the "token compress mode" is enabled, adjacent tokens are considered to be one match.

This function provides the strong exception-safety guarantee

An `iterator_range` delimiting the match. Returned iterator is either `RangeT::iterator` or `RangeT::const_iterator`, depending on the constness of the input parameter.

Defines generic replace algorithms. Each algorithm replaces part(s) of the input. The part to be replaced is looked up using a Finder object. Result of finding is then used by a Formatter object to generate the replacement.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const RangeT &

An input sequence

` `FinderT

A Finder object used to search for a match to be replaced

` `FormatterT

A Formatter object used to format a match

`
SequenceT `const SequenceT &` `FinderT` `FormatterT`
Generic replace algorithm.

Use the Finder to search for a substring. Use the Formatter to format this substring and replace it in the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input sequence

` `FinderT

A Finder object used to search for a match to be replaced

` `FormatterT

A Formatter object used to format a match

` Generic replace algorithm.

Use the Finder to search for a substring. Use the Formatter to format this substring and replace it in the input. The input is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const RangeT &

An input sequence

` `FinderT

A Finder object used to search for a match to be replaced

` `FormatterT

A Formatter object used to format a match

`
SequenceT `const SequenceT &` `FinderT` `FormatterT`
Generic replace all algorithm.

Use the Finder to search for a substring. Use the Formatter to format this substring and replace it in the input. Repeat this for all matching substrings. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input sequence

` `FinderT

A Finder object used to search for a match to be replaced

` `FormatterT

A Formatter object used to format a match

` Generic replace all algorithm.

Use the Finder to search for a substring. Use the Formatter to format this substring and replace it in the input. Repeat this for all matching substrings.The input is modified in-place.

Defines find iterator classes. Find iterator repeatedly applies a Finder to the specified input string to search for matches. Dereferencing the iterator yields the current match or a range between the last and the current match depending on the iterator used.

iterator_facade< find_iterator< IteratorT >, const iterator_range< IteratorT >, forward_traversal_tag >

boost::algorithm::find_iterator

find_iterator

Find iterator encapsulates a Finder and allows for incremental searching in a string. Each increment moves the iterator to the next match.

Find iterator is a readable forward traversal iterator.

Dereferencing the iterator yields an iterator_range delimiting the current match.

bool Eof check.

Check the eof condition. Eof condition means that there is nothing more to be searched i.e. `find_iterator` is after the last match.

Default constructor.

Construct null iterator. All null iterators are equal.

eof()==true

const `find_iterator` &
Copy constructor.

Construct a copy of the `find_iterator`

IteratorT
IteratorT
FinderT
Constructor.

Construct new `find_iterator` for a given finder and a range.

RangeT &
FinderT
Constructor.

Construct new `find_iterator` for a given finder and a range.

const match_type &
void
bool `const `find_iterator` &`
iterator_facade< split_iterator< IteratorT >, const iterator_range< IteratorT >, forward_traversal_tag >

boost::algorithm::split_iterator

split_iterator

Split iterator encapsulates a Finder and allows for incremental searching in a string. Unlike the find iterator, split iterator iterates through gaps between matches.

Find iterator is a readable forward traversal iterator.

Dereferencing the iterator yields an iterator_range delimiting the current match.

bool Eof check.

Check the eof condition. Eof condition means that there is nothing more to be searched i.e. `find_iterator` is after the last match.

Default constructor.

Construct null iterator. All null iterators are equal.

eof()==true

const `split_iterator` &
Copy constructor.

Construct a copy of the `split_iterator`

IteratorT
IteratorT
FinderT
Constructor.

Construct new `split_iterator` for a given finder and a range.

RangeT &
FinderT
Constructor.

Construct new `split_iterator` for a given finder and a collection.

const match_type &
void
bool `const `split_iterator` &`
`find_iterator`< typename range_iterator< RangeT >::type > `RangeT &` `FinderT` find iterator construction helper

Construct a find iterator to iterate through the specified string

`split_iterator`< typename range_iterator< RangeT >::type > `RangeT &` `FinderT` split iterator construction helper

Construct a split iterator to iterate through the specified collection

Defines Finder generators. Finder object is a functor which is able to find a substring matching a specific criteria in the input. Finders are used as a pluggable components for replace, find and split facilities. This header contains generator functions for finders provided in this library.

unspecified `const RangeT &

A substring to be searched for.

`
unspecified `const RangeT &` `PredicateT`
"First" finder

Construct the `first_finder`. The finder searches for the first occurrence of the string in a given input. The result is given as an `iterator_range` delimiting the match.

An instance of the `first_finder` object

unspecified `const RangeT &

A substring to be searched for.

`
unspecified `const RangeT &` `PredicateT`
"Last" finder

Construct the `last_finder`. The finder searches for the last occurrence of the string in a given input. The result is given as an `iterator_range` delimiting the match.

An instance of the `last_finder` object

unspecified `const RangeT &

A substring to be searched for.

` `int

An index of the match to be find

`
unspecified `const RangeT &` `int` `PredicateT`
"Nth" finder

Construct the `nth_finder`. The finder searches for the n-th (zero-indexed) occurrence of the string in a given input. The result is given as an `iterator_range` delimiting the match.

An instance of the `nth_finder` object

unspecified `int

The size of the head

` "Head" finder

Construct the `head_finder`. The finder returns a head of a given input. The head is a prefix of a string up to n elements in size. If an input has less then n elements, whole input is considered a head. The result is given as an `iterator_range` delimiting the match.

An instance of the `head_finder` object

unspecified `int

The size of the head

` "Tail" finder

Construct the `tail_finder`. The finder returns a tail of a given input. The tail is a suffix of a string up to n elements in size. If an input has less then n elements, whole input is considered a head. The result is given as an `iterator_range` delimiting the match.

An instance of the `tail_finder` object

unspecified `PredicateT

An element selection predicate

` `token_compress_mode_typetoken_compress_off

Compress flag

` "Token" finder

Construct the `token_finder`. The finder searches for a token specified by a predicate. It is similar to std::find_if algorithm, with an exception that it return a range of instead of a single iterator.

If "compress token mode" is enabled, adjacent matching tokens are concatenated into one match. Thus the finder can be used to search for continuous segments of characters satisfying the given predicate.

The result is given as an `iterator_range` delimiting the match.

An instance of the `token_finder` object

unspecified `ForwardIteratorT

Beginning of the range

` `ForwardIteratorT

End of the range

`
unspecified `iterator_range< ForwardIteratorT >`
"Range" finder

Construct the `range_finder`. The finder does not perform any operation. It simply returns the given range for any input.

An instance of the `range_finger` object

Defines Formatter generators. Formatter is a functor which formats a string according to given parameters. A Formatter works in conjunction with a Finder. A Finder can provide additional information for a specific Formatter. An example of such a cooperation is regex_finder and regex_formatter.

Formatters are used as pluggable components for replace facilities. This header contains generator functions for the Formatters provided in this library.

unspecified `const RangeT &

A predefined value used as a result for formatting

` Constant formatter.

Constructs a `const_formatter`. Const formatter always returns the same value, regardless of the parameter.

An instance of the `const_formatter` object.

unspecified Identity formatter.

Constructs an `identity_formatter`. Identity formatter always returns the parameter.

An instance of the `identity_formatter` object.

unspecified `const RangeT &` Empty formatter.

Constructs an `empty_formatter`. Empty formatter always returns an empty sequence.

An instance of the `empty_formatter` object.

unspecified `const FinderT &

a finder used to select a portion of the formatted sequence

` Empty formatter.

Constructs a `dissect_formatter`. Dissect formatter uses a specified finder to extract a portion of the formatted sequence. The first finder's match is returned as a result

An instance of the `dissect_formatter` object.

Defines generic split algorithms. Split algorithms can be used to divide a sequence into several part according to a given criteria. Result is given as a 'container of containers' where elements are copies or references to extracted parts.

There are two algorithms provided. One iterates over matching substrings, the other one over the gaps between these matches.

SequenceSequenceT & `SequenceSequenceT &

A 'container container' to contain the result of search. Both outer and inner container must have constructor taking a pair of iterators as an argument. Typical type of the result is `std::vector<boost::iterator_range<iterator>>` (each element of such a vector will container a range delimiting a match).

` `RangeT &&

A container which will be searched.

` `FinderT

A Finder object used for searching

` Iter find algorithm.

This algorithm executes a given finder in iteration on the input, until the end of input is reached, or no match is found. Iteration is done using built-in `find_iterator`, so the real searching is performed only when needed. In each iteration new match is found and added to the result.

Prior content of the result will be overwritten.

A reference to the result

SequenceSequenceT & `SequenceSequenceT &

A 'container container' to contain the result of search. Both outer and inner container must have constructor taking a pair of iterators as an argument. Typical type of the result is `std::vector<boost::iterator_range<iterator>>` (each element of such a vector will container a range delimiting a match).

` `RangeT &&

A container which will be searched.

` `FinderT

A finder object used for searching

` Split find algorithm.

This algorithm executes a given finder in iteration on the input, until the end of input is reached, or no match is found. Iteration is done using built-in `find_iterator`, so the real searching is performed only when needed. Each match is used as a separator of segments. These segments are then returned in the result.

Prior content of the result will be overwritten.

A reference to the result

Defines join algorithm.

Join algorithm is a counterpart to split algorithms. It joins strings from a 'list' by adding user defined separator. Additionally there is a version that allows simple filtering by providing a predicate.

range_value< SequenceSequenceT >::type `const SequenceSequenceT &

A container that holds the input strings. It must be a container-of-containers.

` `const Range1T &

A string that will separate the joined segments.

` Join algorithm.

This algorithm joins all strings in a 'list' into one long string. Segments are concatenated by given separator.

This function provides the strong exception-safety guarantee

Concatenated string.

range_value< SequenceSequenceT >::type `const SequenceSequenceT &

A container that holds the input strings. It must be a container-of-containers.

` `const Range1T &

A string that will separate the joined segments.

` `PredicateT

A segment selection predicate

` Conditional join algorithm.

This algorithm joins all strings in a 'list' into one long string. Segments are concatenated by given separator. Only segments that satisfy the predicate will be added to the result.

This function provides the strong exception-safety guarantee

Concatenated string.

Defines string-related predicates. The predicates determine whether a substring is contained in the input string under various conditions: a string starts with the substring, ends with the substring, simply contains the substring or if both strings are equal. Additionaly the algorithm `all()` checks all elements of a container to satisfy a condition.

All predicates provide the strong exception guarantee.

bool `const Range1T &

An input sequence

` `const Range2T &

A test sequence

` `PredicateT

An element comparison predicate

`
bool `const Range1T &` `const Range2T &`
'Starts with' predicate

This predicate holds when the test string is a prefix of the Input. In other words, if the input starts with the test. When the optional predicate is specified, it is used for character-wise comparison.

This function provides the strong exception-safety guarantee

The result of the test

bool `const Range1T &

An input sequence

` `const Range2T &

A test sequence

` `const std::locale &std::locale()

A locale used for case insensitive comparison

` 'Starts with' predicate ( case insensitive )

This predicate holds when the test string is a prefix of the Input. In other words, if the input starts with the test. Elements are compared case insensitively.

This function provides the strong exception-safety guarantee

The result of the test

bool `const Range1T &

An input sequence

` `const Range2T &

A test sequence

` `PredicateT

An element comparison predicate

`
bool `const Range1T &` `const Range2T &`
'Ends with' predicate

This predicate holds when the test string is a suffix of the Input. In other words, if the input ends with the test. When the optional predicate is specified, it is used for character-wise comparison.

This function provides the strong exception-safety guarantee

The result of the test

bool `const Range1T &

An input sequence

` `const Range2T &

A test sequence

` `const std::locale &std::locale()

A locale used for case insensitive comparison

` 'Ends with' predicate ( case insensitive )

This predicate holds when the test container is a suffix of the Input. In other words, if the input ends with the test. Elements are compared case insensitively.

This function provides the strong exception-safety guarantee

The result of the test

bool `const Range1T &

An input sequence

` `const Range2T &

A test sequence

` `PredicateT

An element comparison predicate

`
bool `const Range1T &` `const Range2T &`
'Contains' predicate

This predicate holds when the test container is contained in the Input. When the optional predicate is specified, it is used for character-wise comparison.

This function provides the strong exception-safety guarantee

The result of the test

bool `const Range1T &

An input sequence

` `const Range2T &

A test sequence

` `const std::locale &std::locale()

A locale used for case insensitive comparison

` 'Contains' predicate ( case insensitive )

This predicate holds when the test container is contained in the Input. Elements are compared case insensitively.

This function provides the strong exception-safety guarantee

The result of the test

bool `const Range1T &

An input sequence

` `const Range2T &

A test sequence

` `PredicateT

An element comparison predicate

`
bool `const Range1T &` `const Range2T &`
'Equals' predicate

This predicate holds when the test container is equal to the input container i.e. all elements in both containers are same. When the optional predicate is specified, it is used for character-wise comparison.

This is a two-way version of `std::equal` algorithm

This function provides the strong exception-safety guarantee

The result of the test

bool `const Range1T &

An input sequence

` `const Range2T &

A test sequence

` `const std::locale &std::locale()

A locale used for case insensitive comparison

` 'Equals' predicate ( case insensitive )

This predicate holds when the test container is equal to the input container i.e. all elements in both containers are same. Elements are compared case insensitively.

This is a two-way version of `std::equal` algorithm

This function provides the strong exception-safety guarantee

The result of the test

bool `const Range1T &

First argument

` `const Range2T &

Second argument

` `PredicateT

Comparison predicate

`
bool `const Range1T &` `const Range2T &`
Lexicographical compare predicate.

This predicate is an overload of std::lexicographical_compare for range arguments

It check whether the first argument is lexicographically less then the second one.

If the optional predicate is specified, it is used for character-wise comparison

This function provides the strong exception-safety guarantee

The result of the test

bool `const Range1T &

First argument

` `const Range2T &

Second argument

` `const std::locale &std::locale()

A locale used for case insensitive comparison

` Lexicographical compare predicate (case-insensitive)

This predicate is an overload of std::lexicographical_compare for range arguments. It check whether the first argument is lexicographically less then the second one. Elements are compared case insensitively

This function provides the strong exception-safety guarantee

The result of the test

bool `const RangeT &

An input sequence

` `PredicateT

A predicate

` 'All' predicate

This predicate holds it all its elements satisfy a given condition, represented by the predicate.

This function provides the strong exception-safety guarantee

The result of the test

Defines regex variants of the algorithms.

iterator_range< typename range_iterator< RangeT >::type > `RangeT &

A container which will be searched.

` `const basic_regex< CharT, RegexTraitsT > &

A regular expression

` `match_flag_typematch_default

Regex options

` Find regex algorithm.

Search for a substring matching the given regex in the input.

This function provides the strong exception-safety guarantee

An `iterator_range` delimiting the match. Returned iterator is either `RangeT::iterator` or `RangeT::const_iterator`, depending on the constness of the input parameter.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const RangeT &

An input string

` `const basic_regex< CharT, RegexTraitsT > &

A regular expression

` `const std::basic_string< CharT, FormatStringTraitsT, FormatStringAllocatorT > &

Regex format definition

` `match_flag_typematch_default|format_default

Regex options

`
SequenceT `const SequenceT &` `const basic_regex< CharT, RegexTraitsT > &` `const std::basic_string< CharT, FormatStringTraitsT, FormatStringAllocatorT > &` `match_flag_typematch_default|format_default`
Replace regex algorithm.

Search for a substring matching given regex and format it with the specified format.

The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const basic_regex< CharT, RegexTraitsT > &

A regular expression

` `const std::basic_string< CharT, FormatStringTraitsT, FormatStringAllocatorT > &

Regex format definition

` `match_flag_typematch_default|format_default

Regex options

` Replace regex algorithm.

Search for a substring matching given regex and format it with the specified format. The input string is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const RangeT &

An input string

` `const basic_regex< CharT, RegexTraitsT > &

A regular expression

` `const std::basic_string< CharT, FormatStringTraitsT, FormatStringAllocatorT > &

Regex format definition

` `match_flag_typematch_default|format_default

Regex options

`
SequenceT `const SequenceT &` `const basic_regex< CharT, RegexTraitsT > &` `const std::basic_string< CharT, FormatStringTraitsT, FormatStringAllocatorT > &` `match_flag_typematch_default|format_default`
Replace all regex algorithm.

Format all substrings, matching given regex, with the specified format. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const basic_regex< CharT, RegexTraitsT > &

A regular expression

` `const std::basic_string< CharT, FormatStringTraitsT, FormatStringAllocatorT > &

Regex format definition

` `match_flag_typematch_default|format_default

Regex options

` Replace all regex algorithm.

Format all substrings, matching given regex, with the specified format. The input string is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const RangeT &

An input string

` `const basic_regex< CharT, RegexTraitsT > &

A regular expression

` `match_flag_typematch_default

Regex options

`
SequenceT `const SequenceT &` `const basic_regex< CharT, RegexTraitsT > &` `match_flag_typematch_default`
Erase regex algorithm.

Remove a substring matching given regex from the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const basic_regex< CharT, RegexTraitsT > &

A regular expression

` `match_flag_typematch_default

Regex options

` Erase regex algorithm.

Remove a substring matching given regex from the input. The input string is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const RangeT &

An input string

` `const basic_regex< CharT, RegexTraitsT > &

A regular expression

` `match_flag_typematch_default

Regex options

`
SequenceT `const SequenceT &` `const basic_regex< CharT, RegexTraitsT > &` `match_flag_typematch_default`
Erase all regex algorithm.

Erase all substrings, matching given regex, from the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const basic_regex< CharT, RegexTraitsT > &

A regular expression

` `match_flag_typematch_default

Regex options

` Erase all regex algorithm.

Erase all substrings, matching given regex, from the input. The input string is modified in-place.

SequenceSequenceT & `SequenceSequenceT &

A container that can hold copies of references to the substrings.

` `const RangeT &

A container which will be searched.

` `const basic_regex< CharT, RegexTraitsT > &

A regular expression

` `match_flag_typematch_default

Regex options

` Find all regex algorithm.

This algorithm finds all substrings matching the give regex in the input.

Each part is copied and added as a new element to the output container. Thus the result container must be able to hold copies of the matches (in a compatible structure like std::string) or a reference to it (e.g. using the iterator range class). Examples of such a container are `std::vector<std::string>` or `std::list<boost::iterator_range<std::string::iterator>>`

Prior content of the result will be overwritten.

This function provides the strong exception-safety guarantee

A reference to the result

SequenceSequenceT & `SequenceSequenceT &

A container that can hold copies of references to the substrings.

` `const RangeT &

A container which will be searched.

` `const basic_regex< CharT, RegexTraitsT > &

A regular expression

` `match_flag_typematch_default

Regex options

` Split regex algorithm.

Tokenize expression. This function is equivalent to C strtok. Input sequence is split into tokens, separated by separators. Separator is an every match of the given regex. Each part is copied and added as a new element to the output container. Thus the result container must be able to hold copies of the matches (in a compatible structure like std::string) or a reference to it (e.g. using the iterator range class). Examples of such a container are `std::vector<std::string>` or `std::list<boost::iterator_range<std::string::iterator>>`

Prior content of the result will be overwritten.

This function provides the strong exception-safety guarantee

A reference to the result

range_value< SequenceSequenceT >::type `const SequenceSequenceT &

A container that holds the input strings. It must be a container-of-containers.

` `const Range1T &

A string that will separate the joined segments.

` `const basic_regex< CharT, RegexTraitsT > &

A regular expression

` `match_flag_typematch_default

Regex options

` Conditional join algorithm.

This algorithm joins all strings in a 'list' into one long string. Segments are concatenated by given separator. Only segments that match the given regular expression will be added to the result

This is a specialization of join_if algorithm.

This function provides the strong exception-safety guarantee

Concatenated string.

Defines the `regex_finder` and `regex_formatter` generators. These two functors are designed to work together. `regex_formatter` uses additional information about a match contained in the regex_finder search result.

unspecified `const basic_regex< CharT, RegexTraitsT > &

A regular expression

` `match_flag_typematch_default

Regex search options

` "Regex" finder

Construct the `regex_finder`. Finder uses the regex engine to search for a match. Result is given in `regex_search_result`. This is an extension of the iterator_range. In addition it contains match results from the `regex_search` algorithm.

An instance of the `regex_finder` object

unspecified `const std::basic_string< CharT, TraitsT, AllocT > &

Regex format definition

` `match_flag_typeformat_default

Format flags

` Regex formatter.

Construct the `regex_formatter`. Regex formatter uses the regex engine to format a match found by the `regex_finder`. This formatted it designed to closely cooperate with `regex_finder`.

An instance of the `regex_formatter` functor

Defines various replace algorithms. Each algorithm replaces part(s) of the input according to set of searching and replace criteria.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input string

` `const iterator_range< typename range_const_iterator< Range1T >::type > &

A range in the input to be substituted

` `const Range2T &

A substitute string

`
SequenceT `const SequenceT &` `const iterator_range< typename range_const_iterator< SequenceT >::type > &` `const RangeT &`
Replace range algorithm.

Replace the given range in the input string. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const iterator_range< typename range_iterator< SequenceT >::type > &

A range in the input to be substituted

` `const RangeT &

A substitute string

` Replace range algorithm.

Replace the given range in the input string. The input sequence is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input string

` `const Range2T &

A substring to be searched for

` `const Range3T &

A substitute string

`
SequenceT `const SequenceT &` `const Range1T &` `const Range2T &`
Replace first algorithm.

Replace the first match of the search substring in the input with the format string. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const Range1T &

A substring to be searched for

` `const Range2T &

A substitute string

` Replace first algorithm.

replace the first match of the search substring in the input with the format string. The input sequence is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input string

` `const Range2T &

A substring to be searched for

` `const Range3T &

A substitute string

` `const std::locale &std::locale()

A locale used for case insensitive comparison

`
SequenceT `const SequenceT &` `const Range2T &` `const Range1T &` `const std::locale &std::locale()`
Replace first algorithm ( case insensitive )

Replace the first match of the search substring in the input with the format string. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. Searching is case insensitive.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const Range1T &

A substring to be searched for

` `const Range2T &

A substitute string

` `const std::locale &std::locale()

A locale used for case insensitive comparison

` Replace first algorithm ( case insensitive )

Replace the first match of the search substring in the input with the format string. Input sequence is modified in-place. Searching is case insensitive.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input string

` `const Range2T &

A substring to be searched for

` `const Range3T &

A substitute string

`
SequenceT `const SequenceT &` `const Range1T &` `const Range2T &`
Replace last algorithm.

Replace the last match of the search string in the input with the format string. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const Range1T &

A substring to be searched for

` `const Range2T &

A substitute string

` Replace last algorithm.

Replace the last match of the search string in the input with the format string. Input sequence is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input string

` `const Range2T &

A substring to be searched for

` `const Range3T &

A substitute string

` `const std::locale &std::locale()

A locale used for case insensitive comparison

`
SequenceT `const SequenceT &` `const Range1T &` `const Range2T &` `const std::locale &std::locale()`
Replace last algorithm ( case insensitive )

Replace the last match of the search string in the input with the format string. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. Searching is case insensitive.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const Range1T &

A substring to be searched for

` `const Range2T &

A substitute string

` `const std::locale &std::locale()

A locale used for case insensitive comparison

` Replace last algorithm ( case insensitive )

Replace the last match of the search string in the input with the format string.The input sequence is modified in-place. Searching is case insensitive.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input string

` `const Range2T &

A substring to be searched for

` `int

An index of the match to be replaced. The index is 0-based. For negative N, matches are counted from the end of string.

` `const Range3T &

A substitute string

`
SequenceT `const SequenceT &` `const Range1T &` `int` `const Range2T &`
Replace nth algorithm.

Replace an Nth (zero-indexed) match of the search string in the input with the format string. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const Range1T &

A substring to be searched for

` `int

An index of the match to be replaced. The index is 0-based. For negative N, matches are counted from the end of string.

` `const Range2T &

A substitute string

` Replace nth algorithm.

Replace an Nth (zero-indexed) match of the search string in the input with the format string. Input sequence is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input string

` `const Range2T &

A substring to be searched for

` `int

An index of the match to be replaced. The index is 0-based. For negative N, matches are counted from the end of string.

` `const Range3T &

A substitute string

` `const std::locale &std::locale()

A locale used for case insensitive comparison

`
SequenceT `const SequenceT &` `const Range1T &` `int` `const Range2T &` `const std::locale &std::locale()`
Replace nth algorithm ( case insensitive )

Replace an Nth (zero-indexed) match of the search string in the input with the format string. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. Searching is case insensitive.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const Range1T &

A substring to be searched for

` `int

An index of the match to be replaced. The index is 0-based. For negative N, matches are counted from the end of string.

` `const Range2T &

A substitute string

` `const std::locale &std::locale()

A locale used for case insensitive comparison

` Replace nth algorithm ( case insensitive )

Replace an Nth (zero-indexed) match of the search string in the input with the format string. Input sequence is modified in-place. Searching is case insensitive.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input string

` `const Range2T &

A substring to be searched for

` `const Range3T &

A substitute string

`
SequenceT `const SequenceT &` `const Range1T &` `const Range2T &`
Replace all algorithm.

Replace all occurrences of the search string in the input with the format string. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const Range1T &

A substring to be searched for

` `const Range2T &

A substitute string

` Replace all algorithm.

Replace all occurrences of the search string in the input with the format string. The input sequence is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input string

` `const Range2T &

A substring to be searched for

` `const Range3T &

A substitute string

` `const std::locale &std::locale()

A locale used for case insensitive comparison

`
SequenceT `const SequenceT &` `const Range1T &` `const Range2T &` `const std::locale &std::locale()`
Replace all algorithm ( case insensitive )

Replace all occurrences of the search string in the input with the format string. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. Searching is case insensitive.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `const Range1T &

A substring to be searched for

` `const Range2T &

A substitute string

` `const std::locale &std::locale()

A locale used for case insensitive comparison

` Replace all algorithm ( case insensitive )

Replace all occurrences of the search string in the input with the format string.The input sequence is modified in-place. Searching is case insensitive.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input string

` `int

Length of the head. For N>=0, at most N characters are extracted. For N<0, size(Input)-|N| characters are extracted.

` `const Range2T &

A substitute string

`
SequenceT `const SequenceT &` `int` `const RangeT &`
Replace head algorithm.

Replace the head of the input with the given format string. The head is a prefix of a string of given size. If the sequence is shorter then required, whole string if considered to be the head. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `int

Length of the head. For N>=0, at most N characters are extracted. For N<0, size(Input)-|N| characters are extracted.

` `const RangeT &

A substitute string

` Replace head algorithm.

Replace the head of the input with the given format string. The head is a prefix of a string of given size. If the sequence is shorter then required, the whole string is considered to be the head. The input sequence is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const Range1T &

An input string

` `int

Length of the tail. For N>=0, at most N characters are extracted. For N<0, size(Input)-|N| characters are extracted.

` `const Range2T &

A substitute string

`
SequenceT `const SequenceT &` `int` `const RangeT &`
Replace tail algorithm.

Replace the tail of the input with the given format string. The tail is a suffix of a string of given size. If the sequence is shorter then required, whole string is considered to be the tail. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator.

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a modified copy of the input

void `SequenceT &

An input string

` `int

Length of the tail. For N>=0, at most N characters are extracted. For N<0, size(Input)-|N| characters are extracted.

` `const RangeT &

A substitute string

` Replace tail algorithm.

Replace the tail of the input with the given format sequence. The tail is a suffix of a string of given size. If the sequence is shorter then required, the whole string is considered to be the tail. The input sequence is modified in-place.

Traits defined in this header are used by various algorithms to achieve better performance for specific containers. Traits provide fail-safe defaults. If a container supports some of these features, it is possible to specialize the specific trait for this container. For lacking compilers, it is possible of define an override for a specific tester function.

Due to a language restriction, it is not currently possible to define specializations for stl containers without including the corresponding header. To decrease the overhead needed by this inclusion, user can selectively include a specialization header for a specific container. They are located in boost/algorithm/string/stl directory. Alternatively she can include boost/algorithm/string/std_collection_traits.hpp header which contains specializations for all stl containers.

Const time erase trait.

This trait specifies that the sequence's erase method has constant time complexity.

mpl::bool_< `has_const_time_erase`< T >::value >
const bool
Const time insert trait.

This trait specifies that the sequence's insert method has constant time complexity.

mpl::bool_< `has_const_time_insert`< T >::value >
const bool
Native replace trait.

This trait specifies that the sequence has `std::string` like replace method

mpl::bool_< `has_native_replace`< T >::value >
const bool
Stable iterators trait.

This trait specifies that the sequence has stable iterators. It means that operations like insert/erase/replace do not invalidate iterators.

mpl::bool_< `has_stable_iterators`< T >::value >
const bool

Defines basic split algorithms. Split algorithms can be used to divide a string into several parts according to given criteria.

Each part is copied and added as a new element to the output container. Thus the result container must be able to hold copies of the matches (in a compatible structure like std::string) or a reference to it (e.g. using the iterator range class). Examples of such a container are `std::vector<std::string>` or `std::list<boost::iterator_range<std::string::iterator>>`

SequenceSequenceT & `SequenceSequenceT &

A container that can hold copies of references to the substrings

` `Range1T &&

A container which will be searched.

` `const Range2T &

A substring to be searched for.

` Find all algorithm.

This algorithm finds all occurrences of the search string in the input.

Each part is copied and added as a new element to the output container. Thus the result container must be able to hold copies of the matches (in a compatible structure like std::string) or a reference to it (e.g. using the iterator range class). Examples of such a container are `std::vector<std::string>` or `std::list<boost::iterator_range<std::string::iterator>>`

Prior content of the result will be overwritten.

This function provides the strong exception-safety guarantee

A reference the result

SequenceSequenceT & `SequenceSequenceT &

A container that can hold copies of references to the substrings

` `Range1T &&

A container which will be searched.

` `const Range2T &

A substring to be searched for.

` `const std::locale &std::locale()

A locale used for case insensitive comparison

` Find all algorithm ( case insensitive )

This algorithm finds all occurrences of the search string in the input. Each part is copied and added as a new element to the output container. Thus the result container must be able to hold copies of the matches (in a compatible structure like std::string) or a reference to it (e.g. using the iterator range class). Examples of such a container are `std::vector<std::string>` or `std::list<boost::iterator_range<std::string::iterator>>`

Searching is case insensitive.

Prior content of the result will be overwritten.

This function provides the strong exception-safety guarantee

A reference the result

SequenceSequenceT & `SequenceSequenceT &

A container that can hold copies of references to the substrings

` `RangeT &&

A container which will be searched.

` `PredicateT

A predicate to identify separators. This predicate is supposed to return true if a given element is a separator.

` `token_compress_mode_typetoken_compress_off

If eCompress argument is set to token_compress_on, adjacent separators are merged together. Otherwise, every two separators delimit a token.

` Split algorithm.

Tokenize expression. This function is equivalent to C strtok. Input sequence is split into tokens, separated by separators. Separators are given by means of the predicate.

Each part is copied and added as a new element to the output container. Thus the result container must be able to hold copies of the matches (in a compatible structure like std::string) or a reference to it (e.g. using the iterator range class). Examples of such a container are `std::vector<std::string>` or `std::list<boost::iterator_range<std::string::iterator>>`

Prior content of the result will be overwritten.

This function provides the strong exception-safety guarantee

A reference the result

This file includes sequence traits for stl containers.

Defines trim algorithms. Trim algorithms are used to remove trailing and leading spaces from a sequence (string). Space is recognized using given locales.

Parametric (`_if`) variants use a predicate (functor) to select which characters are to be trimmed.. Functions take a selection predicate as a parameter, which is used to determine whether a character is a space. Common predicates are provided in classification.hpp header.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const RangeT &

An input range

` `PredicateT

A unary predicate identifying spaces

`
SequenceT `const SequenceT &` `PredicateT`
Left trim - parametric.

Remove all leading spaces from the input. The supplied predicate is used to determine which characters are considered spaces. The result is a trimmed copy of the input. It is returned as a sequence or copied to the output iterator

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a copy of the input

SequenceT `const SequenceT &

An input sequence

` `const std::locale &std::locale()

a locale used for 'space' classification

` Left trim - parametric.

Remove all leading spaces from the input. The result is a trimmed copy of the input.

This function provides the strong exception-safety guarantee

A trimmed copy of the input

void `SequenceT &

An input sequence

` `PredicateT

A unary predicate identifying spaces

` Left trim.

Remove all leading spaces from the input. The supplied predicate is used to determine which characters are considered spaces. The input sequence is modified in-place.

void `SequenceT &

An input sequence

` `const std::locale &std::locale()

A locale used for 'space' classification

` Left trim.

Remove all leading spaces from the input. The Input sequence is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const RangeT &

An input range

` `PredicateT

A unary predicate identifying spaces

`
SequenceT `const SequenceT &` `PredicateT`
Right trim - parametric.

Remove all trailing spaces from the input.

The supplied predicate is used to determine which characters are considered spaces. The result is a trimmed copy of the input. It is returned as a sequence or copied to the output iterator

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a copy of the input

SequenceT `const SequenceT &

An input sequence

` `const std::locale &std::locale()

A locale used for 'space' classification

` Right trim.

Remove all trailing spaces from the input. The result is a trimmed copy of the input

This function provides the strong exception-safety guarantee

A trimmed copy of the input

void `SequenceT &

An input sequence

` `PredicateT

A unary predicate identifying spaces

` Right trim - parametric.

Remove all trailing spaces from the input. The supplied predicate is used to determine which characters are considered spaces. The input sequence is modified in-place.

void `SequenceT &

An input sequence

` `const std::locale &std::locale()

A locale used for 'space' classification

` Right trim.

Remove all trailing spaces from the input. The input sequence is modified in-place.

OutputIteratorT `OutputIteratorT

An output iterator to which the result will be copied

` `const RangeT &

An input range

` `PredicateT

A unary predicate identifying spaces

`
SequenceT `const SequenceT &` `PredicateT`
Trim - parametric.

Remove all trailing and leading spaces from the input. The supplied predicate is used to determine which characters are considered spaces. The result is a trimmed copy of the input. It is returned as a sequence or copied to the output iterator

The second variant of this function provides the strong exception-safety guarantee

An output iterator pointing just after the last inserted character or a copy of the input

SequenceT `const SequenceT &

An input sequence

` `const std::locale &std::locale()

A locale used for 'space' classification

` Trim.

Remove all leading and trailing spaces from the input. The result is a trimmed copy of the input

This function provides the strong exception-safety guarantee

A trimmed copy of the input

void `SequenceT &

An input sequence

` `PredicateT

A unary predicate identifying spaces

` Trim.

Remove all leading and trailing spaces from the input. The supplied predicate is used to determine which characters are considered spaces. The input sequence is modified in-place.

void `SequenceT &

An input sequence

` `const std::locale &std::locale()

A locale used for 'space' classification

` Trim.

Remove all leading and trailing spaces from the input. The input sequence is modified in-place.

Defines trim_all algorithms.

Just like `trim`, `trim_all` removes all trailing and leading spaces from a sequence (string). In addition, spaces in the middle of the sequence are truncated to just one character. Space is recognized using given locales.

`trim_fill` acts as trim_all, but the spaces in the middle are replaces with a user-define sequence of character.

Parametric (`_if`) variants use a predicate (functor) to select which characters are to be trimmed.. Functions take a selection predicate as a parameter, which is used to determine whether a character is a space. Common predicates are provided in classification.hpp header.

SequenceT `const SequenceT &

An input sequence

` `PredicateT

A unary predicate identifying spaces

` Trim All - parametric.

Remove all leading and trailing spaces from the input and compress all other spaces to a single character. The result is a trimmed copy of the input

A trimmed copy of the input

void `SequenceT &

An input sequence

` `PredicateT

A unary predicate identifying spaces

` Trim All.

Remove all leading and trailing spaces from the input and compress all other spaces to a single character. The input sequence is modified in-place.

SequenceT `const SequenceT &

An input sequence

` `const std::locale &std::locale()

A locale used for 'space' classification

` Trim All.

Remove all leading and trailing spaces from the input and compress all other spaces to a single character. The result is a trimmed copy of the input

A trimmed copy of the input

void `SequenceT &

An input sequence

` `const std::locale &std::locale()

A locale used for 'space' classification

` Trim All.

Remove all leading and trailing spaces from the input and compress all other spaces to a single character. The input sequence is modified in-place.

A trimmed copy of the input

SequenceT `const SequenceT &

An input sequence

` `const RangeT &

A string used to fill the inner spaces

` `PredicateT

A unary predicate identifying spaces

` Trim Fill - parametric.

Remove all leading and trailing spaces from the input and replace all every block of consecutive spaces with a fill string defined by user. The result is a trimmed copy of the input

A trimmed copy of the input

void `SequenceT &

An input sequence

` `const RangeT &

A string used to fill the inner spaces

` `PredicateT

A unary predicate identifying spaces

` Trim Fill.

Remove all leading and trailing spaces from the input and replace all every block of consecutive spaces with a fill string defined by user. The input sequence is modified in-place.

SequenceT `const SequenceT &

An input sequence

` `const RangeT &

A string used to fill the inner spaces

` `const std::locale &std::locale()

A locale used for 'space' classification

` Trim Fill.

Remove all leading and trailing spaces from the input and replace all every block of consecutive spaces with a fill string defined by user. The result is a trimmed copy of the input

A trimmed copy of the input

void `SequenceT &

An input sequence

` `const RangeT &

A string used to fill the inner spaces

` `const std::locale &std::locale()

A locale used for 'space' classification

` Trim Fill.

Remove all leading and trailing spaces from the input and replace all every block of consecutive spaces with a fill string defined by user. The input sequence is modified in-place.

A trimmed copy of the input

Cumulative include for string_algo library. In addition to string.hpp contains also regex-related stuff.