boostorg/algorithm
1
0
Fork 1
mirror of https://github.com/boostorg/algorithm.git synced 2025-07-06 09:16:33 +02:00
Code Issues Packages Projects Releases Wiki Activity

Comments cleanup

Browse Source 
[SVN r23447]
This commit is contained in:
Pavol Droba
2004-07-11 22:07:00 +00:00
parent 22b59d1848
commit 029851b0ce
14 changed files with 493 additions and 624 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
include/boost/algorithm/string/case_conv.hpp
View File

@ -32,14 +32,14 @@ namespace boost {
/*! /*!
Each element of the input sequence is converted to lower Each element of the input sequence is converted to lower
case. The result is a copy of the input converted to lower case. case. The result is a copy of the input converted to lower case.
It is returned as a sequence or copied to an output iterator. It is returned as a sequence or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input collection \param Input An input collection
\param Loc A locale used for conversion \param Loc A locale used for conversion
\return \return
An output iterator pointing just after last inserted character or An output iterator pointing just after last inserted character or
a copy of the input a copy of the input
*/ */
template<typename OutputIteratorT, typename CollectionT> template<typename OutputIteratorT, typename CollectionT>
inline OutputIteratorT inline OutputIteratorT
@ -58,8 +58,8 @@ namespace boost {
//! Convert to lower case //! Convert to lower case
/*! /*!
\overload \overload
*/ */
template<typename SequenceT> template<typename SequenceT>
inline SequenceT to_lower_copy( inline SequenceT to_lower_copy(
const SequenceT& Input, const SequenceT& Input,
@ -103,14 +103,14 @@ namespace boost {
/*! /*!
Each element of the input sequence is converted to upper Each element of the input sequence is converted to upper
case. The result is a copy of the input converted to upper case. case. The result is a copy of the input converted to upper case.
It is returned as a sequence or copied to an output iterator It is returned as a sequence or copied to an output iterator
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input collection \param Input An input collection
\param Loc A locale used for conversion \param Loc A locale used for conversion
\return \return
An output iterator pointing just after last inserted character or An output iterator pointing just after last inserted character or
a copy of the input a copy of the input
*/ */
template<typename OutputIteratorT, typename CollectionT> template<typename OutputIteratorT, typename CollectionT>
inline OutputIteratorT inline OutputIteratorT
@ -129,8 +129,8 @@ namespace boost {
//! Convert to upper case //! Convert to upper case
/*! /*!
\overload \overload
*/ */
template<typename SequenceT> template<typename SequenceT>
inline SequenceT to_upper_copy( inline SequenceT to_upper_copy(
const SequenceT& Input, const SequenceT& Input,

106
include/boost/algorithm/string/classification.hpp
View File

@ -216,65 +216,65 @@ namespace boost {
{ {
return detail::is_from_rangeF<CharT>(From,To); return detail::is_from_rangeF<CharT>(From,To);
} }
// predicate combinators ---------------------------------------------------// // predicate combinators ---------------------------------------------------//
//! predicate 'and' composition predicate //! predicate 'and' composition predicate
/*! /*!
Construct the \c class_and predicate. This predicate can be used Construct the \c class_and predicate. This predicate can be used
to logically combine two classification predicates. \c class_and holds, to logically combine two classification predicates. \c class_and holds,
if both predicates return true. if both predicates return true.
\param Pred1 The first predicate \param Pred1 The first predicate
\param Pred2 The second predicate \param Pred2 The second predicate
\return An instance of the \c class_and predicate \return An instance of the \c class_and predicate
*/ */
template<typename Pred1T, typename Pred2T> template<typename Pred1T, typename Pred2T>
inline detail::pred_andF<Pred1T, Pred2T> inline detail::pred_andF<Pred1T, Pred2T>
operator&&( operator&&(
const predicate_facade<Pred1T>& Pred1, const predicate_facade<Pred1T>& Pred1,
const predicate_facade<Pred2T>& Pred2 ) const predicate_facade<Pred2T>& Pred2 )
{ {
return detail::pred_andF<Pred1T,Pred2T>( return detail::pred_andF<Pred1T,Pred2T>(
static_cast<const Pred1T&>(Pred1), static_cast<const Pred1T&>(Pred1),
static_cast<const Pred2T&>(Pred2) ); static_cast<const Pred2T&>(Pred2) );
} }
//! predicate 'or' composition predicate //! predicate 'or' composition predicate
/*! /*!
Construct the \c class_or predicate. This predicate can be used Construct the \c class_or predicate. This predicate can be used
to logically combine two classification predicates. \c class_or holds, to logically combine two classification predicates. \c class_or holds,
if one of the predicates return true. if one of the predicates return true.
\param Pred1 The first predicate \param Pred1 The first predicate
\param Pred2 The second predicate \param Pred2 The second predicate
\return An instance of the \c class_or predicate \return An instance of the \c class_or predicate
*/ */
template<typename Pred1T, typename Pred2T> template<typename Pred1T, typename Pred2T>
inline detail::pred_orF<Pred1T, Pred2T> inline detail::pred_orF<Pred1T, Pred2T>
operator||( operator||(
const predicate_facade<Pred1T>& Pred1, const predicate_facade<Pred1T>& Pred1,
const predicate_facade<Pred2T>& Pred2 ) const predicate_facade<Pred2T>& Pred2 )
{ {
return detail::pred_orF<Pred1T,Pred2T>( return detail::pred_orF<Pred1T,Pred2T>(
static_cast<const Pred1T&>(Pred1), static_cast<const Pred1T&>(Pred1),
static_cast<const Pred2T&>(Pred2)); static_cast<const Pred2T&>(Pred2));
} }
//! predicate negation operator //! predicate negation operator
/*! /*!
Construct the \c class_not predicate. This predicate represents a negation. Construct the \c class_not predicate. This predicate represents a negation.
\c class_or holds, if of the predicates return false. \c class_or holds, if of the predicates return false.
\param Pred The predicate to be negated \param Pred The predicate to be negated
\return An instance of the \c class_not predicate \return An instance of the \c class_not predicate
*/ */
template<typename PredT> template<typename PredT>
inline detail::pred_notF<PredT> inline detail::pred_notF<PredT>
operator!( const predicate_facade<PredT>& Pred ) operator!( const predicate_facade<PredT>& Pred )
{ {
return detail::pred_notF<PredT>(static_cast<const PredT&>(Pred)); return detail::pred_notF<PredT>(static_cast<const PredT&>(Pred));
} }
} // namespace algorithm } // namespace algorithm

2
include/boost/algorithm/string/concept.hpp
View File

@ -24,7 +24,7 @@ namespace boost {
//! Finder concept //! Finder concept
/*! /*!
Defines finder concept. Finder is a functor which selects Defines finder concept. Finder is a functor which selects
an arbitraty part of a container. Search is performed on an arbitrary part of a string. Search is performed on
the range specified by starting and ending iterators. the range specified by starting and ending iterators.
Result of the find operation must be convertible to iterator_range. Result of the find operation must be convertible to iterator_range.

2
include/boost/algorithm/string/detail/classification.hpp
View File

@ -22,7 +22,7 @@
namespace boost { namespace boost {
namespace algorithm { namespace algorithm {
namespace detail { namespace detail {
// classification functors -----------------------------------------------// // classification functors -----------------------------------------------//
// is_classified functor // is_classified functor

263
include/boost/algorithm/string/erase.hpp
View File

@ -29,13 +29,14 @@ namespace boost {
//! Erase range algorithm //! Erase range algorithm
/*! /*!
Remove the given range from the input sequence. Remove the given range from the input. The result is a modified copy of
The result is copied to the given output iterator. the input. It is returned as a sequence or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input sequence
\param SearchRange A range in the input to be substituted \param SearchRange A range in the input to be removed
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template<typename OutputIteratorT, typename CollectionT> template<typename OutputIteratorT, typename CollectionT>
inline OutputIteratorT erase_range_copy( inline OutputIteratorT erase_range_copy(
@ -54,12 +55,7 @@ namespace boost {
//! Erase range algorithm //! Erase range algorithm
/*! /*!
Remove the given range from the input sequence. \overload
The result is a modified copy of the input.
\param Input An input sequence
\param SearchRange A range in the input to be substituted
\return A modified copy of the input
*/ */
template<typename SequenceT> template<typename SequenceT>
inline SequenceT erase_range_copy( inline SequenceT erase_range_copy(
@ -76,11 +72,11 @@ namespace boost {
//! Erase range algorithm //! Erase range algorithm
/*! /*!
Remove the given range from the input sequence. Remove the given range from the input.
The input sequence is modified in-place. The input sequence is modified in-place.
\param Input An input sequence \param Input An input sequence
\param SearchRange A range in the input to be substituted \param SearchRange A range in the input to be removed
*/ */
template<typename SequenceT> template<typename SequenceT>
inline void erase_range( inline void erase_range(
@ -99,13 +95,15 @@ namespace boost {
//! Erase first algorithm //! Erase first algorithm
/*! /*!
Remove the first match of the search sequence from the input. Remove the first match of the string from the input.
The result is copied to the given output iterator. The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
H \param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -125,12 +123,7 @@ H \param Output A output iterator to which the result will be copied
//! Erase first algorithm //! Erase first algorithm
/*! /*!
Remove the first match of the search sequence from the input. \overload
The result is a modified copy of the input.
\param Input An input sequence
\param Search A string to be searched for.
\return A modified copy of the input
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
inline SequenceT erase_first_copy( inline SequenceT erase_first_copy(
@ -145,10 +138,10 @@ H \param Output A output iterator to which the result will be copied
//! Erase first algorithm //! Erase first algorithm
/*! /*!
Remove the first match of the search sequence from the input. Remove the first match of the string from the input.
The input sequence is modified in-place. The input sequence is modified in-place.
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for.
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
@ -166,14 +159,17 @@ H \param Output A output iterator to which the result will be copied
//! Erase first algorithm ( case insensitive ) //! Erase first algorithm ( case insensitive )
/*! /*!
Remove the first match of the search sequence from the input. Remove the first match of the string from the input.
The result is copied to the given output iterator. Searching is case insensitive. The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
Searching is case insensitive.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -194,13 +190,7 @@ H \param Output A output iterator to which the result will be copied
//! Erase first algorithm ( case insensitive ) //! Erase first algorithm ( case insensitive )
/*! /*!
Remove the first match of the search sequence from the input. \overload
The result is a modified copy of the input. Searching is case insensitive.
\param Input An input sequence
\param Search A string to be searched for.
\param Loc a locale used for case insensitive comparison
\return A modified copy of the input
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
inline SequenceT ierase_first_copy( inline SequenceT ierase_first_copy(
@ -216,11 +206,11 @@ H \param Output A output iterator to which the result will be copied
//! Erase first algorithm ( case insensitive ) //! Erase first algorithm ( case insensitive )
/*! /*!
Remove the first match of the search sequence from the input. Remove the first match of the string from the input.
The input sequence is modified in-place. Searching is case insensitive. The input sequence is modified in-place. Searching is case insensitive.
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
@ -239,13 +229,15 @@ H \param Output A output iterator to which the result will be copied
//! Erase last algorithm //! Erase last algorithm
/*! /*!
Remove the last match of the search sequence from the input. Remove the last match of the string from the input.
The result is copied to the given output iterator. The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for.
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -265,12 +257,7 @@ H \param Output A output iterator to which the result will be copied
//! Erase last algorithm //! Erase last algorithm
/*! /*!
Remove the last match of the search sequence from the input. \overload
The result is a modified copy of the input.
\param Input An input sequence
\param Search A string to be searched for.
\return A modified copy of the input
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
inline SequenceT erase_last_copy( inline SequenceT erase_last_copy(
@ -285,11 +272,11 @@ H \param Output A output iterator to which the result will be copied
//! Erase last algorithm //! Erase last algorithm
/*! /*!
Remove the last match of the search sequence from the input. Remove the last match of the string from the input.
The input sequence is modified in-place. The input sequence is modified in-place.
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
inline void erase_last( inline void erase_last(
@ -306,14 +293,17 @@ H \param Output A output iterator to which the result will be copied
//! Erase last algorithm ( case insensitive ) //! Erase last algorithm ( case insensitive )
/*! /*!
Remove the last match of the search sequence from the input. Remove the last match of the string from the input.
The result is copied to the given output iterator. Searching is case insensitive. The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
Searching is case insensitive.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -334,13 +324,7 @@ H \param Output A output iterator to which the result will be copied
//! Erase last algorithm ( case insensitive ) //! Erase last algorithm ( case insensitive )
/*! /*!
Remove the last match of the search sequence from the input. \overload
The result is a modified copy of the input. Searching is case insensitive.
\param Input An input sequence
\param Search A string to be searched for.
\param Loc a locale used for case insensitive comparison
\return A modified copy of the input
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
inline SequenceT ierase_last_copy( inline SequenceT ierase_last_copy(
@ -356,11 +340,11 @@ H \param Output A output iterator to which the result will be copied
//! Erase last algorithm ( case insensitive ) //! Erase last algorithm ( case insensitive )
/*! /*!
Remove the last match of the search sequence from the input. Remove the last match of the string from the input.
The input sequence is modified in-place. Searching is case insensitive. The input sequence is modified in-place. Searching is case insensitive.
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
@ -379,14 +363,17 @@ H \param Output A output iterator to which the result will be copied
//! Erase nth algorithm //! Erase nth algorithm
/*! /*!
Remove the Nth match of the search sequence in the input. Remove the Nth match of the string in the input.
The result is copied to the given output iterator. The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Nth An index of the match to be replaced. The index is 0-based. \param Nth An index of the match to be replaced. The index is 0-based.
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -407,13 +394,7 @@ H \param Output A output iterator to which the result will be copied
//! Erase nth algorithm //! Erase nth algorithm
/*! /*!
Remove the Nth match of the search sequence in the input. \overload
The result is a modified copy of the input.
\param Input An input sequence
\param Search A string to be searched for.
\param Nth An index of the match to be replaced. The index is 0-based.
\return A modified copy of the input
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
inline SequenceT erase_nth_copy( inline SequenceT erase_nth_copy(
@ -429,10 +410,10 @@ H \param Output A output iterator to which the result will be copied
//! Erase nth algorithm //! Erase nth algorithm
/*! /*!
Remove the Nth match of the search sequence in the input. Remove the Nth match of the string in the input.
The input sequence is modified in-place. The input sequence is modified in-place.
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for.
\param Nth An index of the match to be replaced. The index is 0-based. \param Nth An index of the match to be replaced. The index is 0-based.
*/ */
@ -452,15 +433,18 @@ H \param Output A output iterator to which the result will be copied
//! Erase nth algorithm ( case insensitive ) //! Erase nth algorithm ( case insensitive )
/*! /*!
Remove the Nth match of the search sequence in the input. Remove the Nth match of the string in the input.
The result is copied to the given output iterator. Searching is case insensitive. The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
Searching is case insensitive.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for.
\param Nth An index of the match to be replaced. The index is 0-based. \param Nth An index of the match to be replaced. The index is 0-based.
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -482,14 +466,7 @@ H \param Output A output iterator to which the result will be copied
//! Erase nth algorithm //! Erase nth algorithm
/*! /*!
Remove the Nth match of the search sequence in the input. \overload
The result is a modified copy of the input. Searching is case insensitive.
\param Input An input sequence
\param Search A string to be searched for.
\param Nth An index of the match to be replaced. The index is 0-based.
\param Loc a locale used for case insensitive comparison
\return A modified copy of the input
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
inline SequenceT ierase_nth_copy( inline SequenceT ierase_nth_copy(
@ -506,10 +483,10 @@ H \param Output A output iterator to which the result will be copied
//! Erase nth algorithm //! Erase nth algorithm
/*! /*!
Remove the Nth match of the search sequence in the input. Remove the Nth match of the string in the input.
The input sequence is modified in-place. Searching is case insensitive. The input sequence is modified in-place. Searching is case insensitive.
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for.
\param Nth An index of the match to be replaced. The index is 0-based. \param Nth An index of the match to be replaced. The index is 0-based.
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
@ -532,13 +509,17 @@ H \param Output A output iterator to which the result will be copied
//! Erase all algorithm //! Erase all algorithm
/*! /*!
Remove all the occurrences of the search sequence from the input. Remove all the occurrences of the string from the input.
The result is copied to the given output iterator. The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input sequence
\param Search A string to be searched for. \param Search A string to be searched for.
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -558,12 +539,7 @@ H \param Output A output iterator to which the result will be copied
//! Erase all algorithm //! Erase all algorithm
/*! /*!
Remove all the occurrences of the search sequence from the input. \overload
The result is a modified copy of the input.
\param Input An input sequence
\param Search A string to be searched for.
\return A modified copy of the input
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
inline SequenceT erase_all_copy( inline SequenceT erase_all_copy(
@ -578,10 +554,10 @@ H \param Output A output iterator to which the result will be copied
//! Erase all algorithm //! Erase all algorithm
/*! /*!
Remove all the occurrences of the search sequence from the input. Remove all the occurrences of the string from the input.
The input sequence is modified in-place. The input sequence is modified in-place.
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for.
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
@ -599,14 +575,18 @@ H \param Output A output iterator to which the result will be copied
//! Erase all algorithm ( case insensitive ) //! Erase all algorithm ( case insensitive )
/*! /*!
Remove all the occurrences of the search sequence from the input. Remove all the occurrences of the string from the input.
The result is copied to the given output iterator. Searching is case insensitive. The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
Searching is case insensitive.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -627,13 +607,7 @@ H \param Output A output iterator to which the result will be copied
//! Erase all algorithm ( case insensitive ) //! Erase all algorithm ( case insensitive )
/*! /*!
Remove all the occurrences of the search sequence from the input. \overload
The result is a modified copy of the input. Searching is case insensitive.
\param Input An input sequence
\param Search A string to be searched for.
\param Loc a locale used for case insensitive comparison
\return A modified copy of the input
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
inline SequenceT ierase_all_copy( inline SequenceT ierase_all_copy(
@ -649,10 +623,10 @@ H \param Output A output iterator to which the result will be copied
//! Erase all algorithm ( case insensitive ) //! Erase all algorithm ( case insensitive )
/*! /*!
Remove all the occurrences of the search sequence from the input. Remove all the occurrences of the string from the input.
The input sequence is modified in-place. Searching is case insensitive. The input sequence is modified in-place. Searching is case insensitive.
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for.
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
*/ */
@ -674,12 +648,15 @@ H \param Output A output iterator to which the result will be copied
/*! /*!
Remove the head from the input. Head is a prefix of a seqence of given size. Remove the head from the input. Head is a prefix of a seqence of given size.
If the sequence is shorter then required, whole sequence if If the sequence is shorter then required, whole sequence if
considered to be the head. The result is copied to the given output iterator. considered to be the head. The result is a modified copy of the input.
It is returned as a sequence or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param N A length of the head \param N A length of the head
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -698,13 +675,7 @@ H \param Output A output iterator to which the result will be copied
//! Erase head algorithm //! Erase head algorithm
/*! /*!
Remove the head from the input. Head is a prefix of a seqence of given size. \overload
If the sequence is shorter then required, whole sequence if
considered to be the head. The result is a modified copy of the input.
\param Input An input sequence
\param N A length of the head
\return A modified copy of the input
*/ */
template<typename SequenceT> template<typename SequenceT>
inline SequenceT erase_head_copy( inline SequenceT erase_head_copy(
@ -723,7 +694,7 @@ H \param Output A output iterator to which the result will be copied
If the sequence is shorter then required, whole sequence if If the sequence is shorter then required, whole sequence if
considered to be the head. The input sequence is modified in-place. considered to be the head. The input sequence is modified in-place.
\param Input An input sequence \param Input An input string
\param N A length of the head \param N A length of the head
*/ */
template<typename SequenceT> template<typename SequenceT>
@ -743,12 +714,16 @@ H \param Output A output iterator to which the result will be copied
/*! /*!
Remove the tail from the input. Tail is a suffix of a seqence of given size. Remove the tail from the input. Tail is a suffix of a seqence of given size.
If the sequence is shorter then required, whole sequence if If the sequence is shorter then required, whole sequence if
considered to be the tail. The result is copied to the given output iterator. considered to be the tail.
The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param N A length of the head \param N A length of the head
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -767,13 +742,7 @@ H \param Output A output iterator to which the result will be copied
//! Erase tail algorithm //! Erase tail algorithm
/*! /*!
Remove the tail from the input. Tail is a suffix of a seqence of given size. \overload
If the sequence is shorter then required, whole sequence is
considered to be the tail. The result is a modified copy of the input.
\param Input An input sequence
\param N A length of the head
\return A modified copy of the input
*/ */
template<typename SequenceT> template<typename SequenceT>
inline SequenceT erase_tail_copy( inline SequenceT erase_tail_copy(
@ -792,7 +761,7 @@ H \param Output A output iterator to which the result will be copied
If the sequence is shorter then required, whole sequence is If the sequence is shorter then required, whole sequence is
considered to be the tail. The input sequence is modified in-place. considered to be the tail. The input sequence is modified in-place.
\param Input An input sequence \param Input An input string
\param N A length of the head \param N A length of the head
*/ */
template<typename SequenceT> template<typename SequenceT>

65
include/boost/algorithm/string/find.hpp
View File

@ -19,7 +19,7 @@
/*! \file /*! \file
Defines a set of find algorithms. The algorithms are searching Defines a set of find algorithms. The algorithms are searching
for a subsequence of the input. The result is given as an \c iterator_range for a substring if the input. The result is given as an \c iterator_range
delimiting the substring. delimiting the substring.
*/ */
@ -32,7 +32,7 @@ namespace boost {
/*! /*!
Search the input using the given finder. Search the input using the given finder.
\param Input A collection which will be searched. \param Input A string which will be searched.
\param Finder Finder object used for searching. \param Finder Finder object used for searching.
\return \return
An \c iterator_range delimiting the match. An \c iterator_range delimiting the match.
@ -54,10 +54,9 @@ namespace boost {
//! Find first algorithm //! Find first algorithm
/*! /*!
Search for a first match of search sequence in the Search for the first match of the string in the input.
input collection.
\param Input A container which will be searched. \param Input A string which will be searched.
\param Search A string to be searched for. \param Search A string to be searched for.
\return \return
An \c iterator_range delimiting the match. An \c iterator_range delimiting the match.
@ -78,10 +77,10 @@ namespace boost {
//! Find first algorithm ( case insensitive ) //! Find first algorithm ( case insensitive )
/*! /*!
Search for a first match of search sequence in the Search for the first match of the string in the input.
input collection. Searching is case insensitive. Searching is case insensitive.
\param Input A container which will be searched. \param Input A string which will be searched.
\param Search A string to be searched for. \param Search A string to be searched for.
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
\return \return
@ -106,10 +105,9 @@ namespace boost {
//! Find last algorithm //! Find last algorithm
/*! /*!
Search for a last match of search sequence in the Search for the last match of the string in the input.
input collection.
\param Input A container which will be searched. \param Input A string which will be searched.
\param Search A string to be searched for. \param Search A string to be searched for.
\return \return
An \c iterator_range delimiting the match. An \c iterator_range delimiting the match.
@ -130,10 +128,10 @@ namespace boost {
//! Find last algorithm ( case insensitive ) //! Find last algorithm ( case insensitive )
/*! /*!
Search for a last match of search sequence in the Search for the last match a string in the input.
input collection. Searching is case insensitive. Searching is case insensitive.
\param Input A container which will be searched. \param Input A string which will be searched.
\param Search A string to be searched for. \param Search A string to be searched for.
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
\return \return
@ -158,12 +156,12 @@ namespace boost {
//! Find n-th algorithm //! Find n-th algorithm
/*! /*!
Search for an n-th match of search sequence in the Search for the n-th (zero-indexed) match of the string in the
input collection. input.
\param Input A container which will be searched. \param Input A string which will be searched.
\param Search A string to be searched for. \param Search A string to be searched for.
\param Nth An index of the match to be found. \param Nth An index (zero-indexed) of the match to be found.
\return \return
An \c iterator_range delimiting the match. An \c iterator_range delimiting the match.
Returned iterator is either \c Collection1T::iterator or Returned iterator is either \c Collection1T::iterator or
@ -184,12 +182,12 @@ namespace boost {
//! Find n-th algorithm ( case insensitive ). //! Find n-th algorithm ( case insensitive ).
/*! /*!
Search for an n-th match of search sequence in the Search for the n-th (zero-indexed) match of the string in the
input collection. Searching is case insensitive. input. Searching is case insensitive.
\param Input A container which will be searched. \param Input A string which will be searched.
\param Search A string to be searched for. \param Search A string to be searched for.
\param Nth An index of the match to be found. \param Nth An index (zero-indexed) of the match to be found.
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
\return \return
An \c iterator_range delimiting the match. An \c iterator_range delimiting the match.
@ -214,11 +212,11 @@ namespace boost {
//! Find head algorithm //! Find head algorithm
/*! /*!
Get the head of the input. Head is a prefix of Get the head of the input. Head is a prefix of the string of the
a seqence of given size. If the sequence is shorter then required, given size. If the input is shorter then required, whole input if considered
whole sequence if considered to be the head. to be the head.
\param Input A container which will be searched. \param Input An input string
\param N A length of the head \param N A length of the head
\return \return
An \c iterator_range delimiting the match. An \c iterator_range delimiting the match.
@ -241,11 +239,11 @@ namespace boost {
//! Find tail algorithm //! Find tail algorithm
/*! /*!
Get the tail of the input. Head is a suffix of Get the head of the input. Head is a suffix of the string of the
a seqence of given size. If the sequence is shorter then required, given size. If the input is shorter then required, whole input if considered
whole sequence if considered to be the tail. to be the tail.
\param Input A container which will be searched. \param Input An input string
\param N A length of the tail \param N A length of the tail
\return \return
An \c iterator_range delimiting the match. An \c iterator_range delimiting the match.
@ -268,10 +266,11 @@ namespace boost {
//! Find token algorithm //! Find token algorithm
/*! /*!
Look for a given token in the collection. Token is specified by a predicate. Look for a given token in the string. Token is a character that matches the
If bCompressed is given, adjacent tokens are considered to be one match. given predicate.
If the "token compress mode" is enabled, adjacent tokens are considered to be one match.
\param Input A container which will be searched. \param Input A input string.
\param Pred An unary predicate to identify a token \param Pred An unary predicate to identify a token
\param eCompress Enable/Disable compressing of adjacent tokens \param eCompress Enable/Disable compressing of adjacent tokens
\return \return

31
include/boost/algorithm/string/find_format.hpp
View File

@ -33,13 +33,15 @@ namespace boost {
/*! /*!
Use the Finder to search for a substring. Use the Formatter to format Use the Finder to search for a substring. Use the Formatter to format
this substring and replace it in the input. this substring and replace it in the input.
The resulting sequence is copied to the given output iterator. The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input sequence
\param Finder A Finder object used to search for a match to be replaced \param Finder A Finder object used to search for a match to be replaced
\param Formatter A Formatter object used to format a match \param Formatter A Formatter object used to format a match
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -71,14 +73,7 @@ namespace boost {
//! Generic replace algorithm //! Generic replace algorithm
/*! /*!
Use the Finder to search for a substring. Use the Formatter to format \overload
this substring and replace it in the input.
The result is the modified copy of the input.
\param Input An input sequence
\param Finder A Finder object used to search for a match to be replaced
\param Formatter A Formatter object used to format a match
\return A modified copy of the input
*/ */
template< template<
typename SequenceT, typename SequenceT,
@ -147,13 +142,15 @@ namespace boost {
Use the Finder to search for a substring. Use the Formatter to format 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 this substring and replace it in the input. Repeat this for all matching
substrings. substrings.
The resulting sequence is copied to the given output iterator. The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input sequence
\param Finder A Finder object used to search for a match to be replaced \param Finder A Finder object used to search for a match to be replaced
\param Formatter A Formatter object used to format a match \param Formatter A Formatter object used to format a match
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -185,15 +182,7 @@ namespace boost {
//! Generic replace all algorithm //! Generic replace all algorithm
/*! /*!
Use the Finder to search for a substring. Use the Formatter to format \overload
this substring and replace it in the input. Repeat this for all matching
substrings.
The result is the modified copy of the input.
\param Input An input sequence
\param Finder A Finder object used to search for a match to be replaced
\param Formatter A Formatter object used to format a match
\return A modified copy of the input
*/ */
template< template<
typename SequenceT, typename SequenceT,

10
include/boost/algorithm/string/find_iterator.hpp
View File

@ -26,7 +26,7 @@ namespace boost {
//! find_iterator //! find_iterator
/*! /*!
Find iterator encapsulates a Finder and allows Find iterator encapsulates a Finder and allows
an incremental searching in the sequence. an incremental searching in a string.
Each increment moves the iterator to the next match. Each increment moves the iterator to the next match.
Find iterator is readable forward traversal iterator. Find iterator is readable forward traversal iterator.
@ -168,7 +168,7 @@ namespace boost {
//! find iterator construction helper //! find iterator construction helper
/*! /*!
* Construct a find iterator to iterate through the specified collection * Construct a find iterator to iterate through the specified string
*/ */
template<typename CollectionT, typename FinderT> template<typename CollectionT, typename FinderT>
inline find_iterator< inline find_iterator<
@ -186,7 +186,7 @@ namespace boost {
//! split_iterator //! split_iterator
/*! /*!
Split iterator encapsulates a Finder and allows Split iterator encapsulates a Finder and allows
an incremental searching in the sequence. an incremental searching in a string.
Unlike the find iterator, split iterator iterates Unlike the find iterator, split iterator iterates
through gasps between matches. through gasps between matches.
@ -264,8 +264,8 @@ namespace boost {
*/ */
template<typename FinderT, typename CollectionT> template<typename FinderT, typename CollectionT>
split_iterator( split_iterator(
CollectionT& Col, CollectionT& Col,
FinderT Finder ) : FinderT Finder ) :
detail::find_iterator_base<IteratorT>(Finder,0), detail::find_iterator_base<IteratorT>(Finder,0),
m_Match(begin(Col),begin(Col)), m_Match(begin(Col),begin(Col)),
m_Next(begin(Col)), m_Next(begin(Col)),

64
include/boost/algorithm/string/finder.hpp
View File

@ -19,8 +19,7 @@
/*! \file /*! \file
Defines Finder generators. Finder object is a functor which is able to Defines Finder generators. Finder object is a functor which is able to
find a subsequence matching a specific criterium in an input find a substring matching a specific criterium in the input.
sequence.
Finders are used as a pluggable components for replace, find Finders are used as a pluggable components for replace, find
and split facilities. This header contains generator functions and split facilities. This header contains generator functions
for finders provided in this library. for finders provided in this library.
@ -34,10 +33,11 @@ namespace boost {
//! "First" finder //! "First" finder
/*! /*!
Construct the \c first_finder. The finder searches for the first Construct the \c first_finder. The finder searches for the first
occurrence of the search sequence in a given input. occurrence of the string in a given input.
The result is given as a \c iterator_range delimiting the match. The result is given as a \c iterator_range delimiting the match.
\param Search A sequence to be searched for. \param Search A string to be searched for.
\param Comp An element comparison predicate
\return An instance of the \c first_finder object \return An instance of the \c first_finder object
*/ */
template<typename ContainerT> template<typename ContainerT>
@ -55,15 +55,7 @@ namespace boost {
//! "First" finder //! "First" finder
/*! /*!
Construct the \c first_finder. The finder searches for the first \overload
occurrence of the search sequence in a given input.
The result is given as a \c iterator_range delimiting the match.
Elements are compared using the given predicate.
\param Search A sequence to be searched for.
\param Comp An element comparison predicate
\return An instance of the \c first_finder object
*/ */
template<typename ContainerT,typename PredicateT> template<typename ContainerT,typename PredicateT>
inline detail::first_finderF< inline detail::first_finderF<
@ -82,10 +74,11 @@ namespace boost {
//! "Last" finder //! "Last" finder
/*! /*!
Construct the \c last_finder. The finder searches for the last Construct the \c last_finder. The finder searches for the last
occurrence of the search sequence in a given input. occurrence of the string in a given input.
The result is given as a \c iterator_range delimiting the match. The result is given as a \c iterator_range delimiting the match.
\param Search A sequence to be searched for. \param Search A string to be searched for.
\param Comp An element comparison predicate
\return An instance of the \c last_finder object \return An instance of the \c last_finder object
*/ */
template<typename ContainerT> template<typename ContainerT>
@ -102,15 +95,7 @@ namespace boost {
} }
//! "Last" finder //! "Last" finder
/*! /*!
Construct the \c last_finder. The finder searches for the last \overload
occurrence of the search sequence in a given input.
The result is given as a \c iterator_range delimiting the match.
Elements are compared using the given predicate.
\param Search A sequence to be searched for.
\param Comp An element comparison predicate
\return An instance of the \c last_finder object
*/ */
template<typename ContainerT, typename PredicateT> template<typename ContainerT, typename PredicateT>
inline detail::last_finderF< inline detail::last_finderF<
@ -127,12 +112,13 @@ namespace boost {
//! "Nth" finder //! "Nth" finder
/*! /*!
Construct the \c nth_finder. The finder searches for the n-th Construct the \c nth_finder. The finder searches for the n-th (zero-indexed)
occurrence of the search sequence in a given input. occurrence of the string in a given input.
The result is given as a \c iterator_range delimiting the match. The result is given as a \c iterator_range delimiting the match.
\param Search A sequence to be searched for. \param Search A string to be searched for.
\param Nth An index of the match to be find \param Nth An index of the match to be find
\param Comp An element comparison predicate
\return An instance of the \c nth_finder object \return An instance of the \c nth_finder object
*/ */
template<typename ContainerT> template<typename ContainerT>
@ -151,16 +137,7 @@ namespace boost {
} }
//! "Nth" finder //! "Nth" finder
/*! /*!
Construct the \c nth_finder. The finder searches for the n-th \overload
occurrence of the search sequence in a given input.
The result is given as a \c iterator_range delimiting the match.
Elements are compared using the given predicate.
\param Search A sequence to be searched for.
\param Nth An index of the match to be find
\param Comp An element comparison predicate
\return An instance of the \c nth_finder object
*/ */
template<typename ContainerT, typename PredicateT> template<typename ContainerT, typename PredicateT>
inline detail::nth_finderF< inline detail::nth_finderF<
@ -181,7 +158,7 @@ namespace boost {
//! "Head" finder //! "Head" finder
/*! /*!
Construct the \c head_finder. The finder returns a head of a given Construct the \c head_finder. The finder returns a head of a given
input. Head is a prefix of a sequence up to n elements in input. Head is a prefix of a string up to n elements in
size. If an input has less then n elements, whole input is size. If an input has less then n elements, whole input is
considered a head. considered a head.
The result is given as a \c iterator_range delimiting the match. The result is given as a \c iterator_range delimiting the match.
@ -198,7 +175,7 @@ namespace boost {
//! "Tail" finder //! "Tail" finder
/*! /*!
Construct the \c tail_finder. The finder returns a tail of a given Construct the \c tail_finder. The finder returns a tail of a given
input. Tail is a suffix of the sequence up to n elements in input. Tail is a suffix of a string up to n elements in
size. If an input has less then n elements, whole input is size. If an input has less then n elements, whole input is
considered a head. considered a head.
The result is given as a \c iterator_range delimiting the match. The result is given as a \c iterator_range delimiting the match.
@ -219,9 +196,9 @@ namespace boost {
algorithm, with an exception that it return a range of algorithm, with an exception that it return a range of
instead of a single iterator. instead of a single iterator.
If bCompress is set to true, adjacent matching tokens are If "compress token mode" is enabled, adjacent matching tokens are
concatenated into one match. Thus the finder can be used to concatenated into one match. Thus the finder can be used to
search for continuous segments of elements satisfying the search for continuous segments of characters satisfying the
given predicate. given predicate.
The result is given as a \c iterator_range delimiting the match. The result is given as a \c iterator_range delimiting the match.
@ -247,6 +224,7 @@ namespace boost {
\param Begin Beginning of the range \param Begin Beginning of the range
\param End End of the range \param End End of the range
\param Range The range.
\return An instance of the \c range_finger object \return An instance of the \c range_finger object
*/ */
template< typename ForwardIteratorT > template< typename ForwardIteratorT >
@ -259,9 +237,7 @@ namespace boost {
} }
//! "Range" finder //! "Range" finder
/*! /*!
\param Range The range.
\overload \overload
*/ */
template< typename ForwardIteratorT > template< typename ForwardIteratorT >

24
include/boost/algorithm/string/predicate.hpp
View File

@ -34,8 +34,8 @@ namespace boost {
/*! /*!
This predicate holds when the test collection is a prefix of the Input. This predicate holds when the test collection is a prefix of the Input.
In other word, if the input starts with the test. In other word, if the input starts with the test.
When optional predicate is specified, it is used for character-wise When optional predicate is specified, it is used for character-wise
comparison. comparison.
\param Input An input sequence \param Input An input sequence
\param Test A test sequence \param Test A test sequence
@ -71,8 +71,8 @@ namespace boost {
//! 'Starts with' predicate //! 'Starts with' predicate
/*! /*!
\overload \overload
*/ */
template<typename Collection1T, typename Collection2T> template<typename Collection1T, typename Collection2T>
inline bool starts_with( inline bool starts_with(
const Collection1T& Input, const Collection1T& Input,
@ -108,8 +108,8 @@ namespace boost {
/*! /*!
This predicate holds when the test container is a suffix of the Input. This predicate holds when the test container is a suffix of the Input.
In other word, if the input ends with the test. In other word, if the input ends with the test.
When optional predicate is specified, it is used for character-wise When optional predicate is specified, it is used for character-wise
comparison. comparison.
\param Input An input sequence \param Input An input sequence
@ -141,7 +141,7 @@ namespace boost {
//! 'Ends with' predicate //! 'Ends with' predicate
/*! /*!
\overload \overload
*/ */
template<typename Collection1T, typename Collection2T> template<typename Collection1T, typename Collection2T>
inline bool ends_with( inline bool ends_with(
@ -177,7 +177,7 @@ namespace boost {
/*! /*!
This predicate holds when the test container is contained in the Input. This predicate holds when the test container is contained in the Input.
When optional predicate is specified, it is used for character-wise When optional predicate is specified, it is used for character-wise
comparison. comparison.
\param Input An input sequence \param Input An input sequence
\param Test A test sequence \param Test A test sequence
@ -201,8 +201,8 @@ namespace boost {
//! 'Contains' predicate //! 'Contains' predicate
/*! /*!
\overload \overload
*/ */
template<typename Collection1T, typename Collection2T> template<typename Collection1T, typename Collection2T>
inline bool contains( inline bool contains(
const Collection1T& Input, const Collection1T& Input,
@ -237,7 +237,7 @@ namespace boost {
This predicate holds when the test container is equal to the This predicate holds when the test container is equal to the
input container i.e. all elements in both containers are same. input container i.e. all elements in both containers are same.
When optional predicate is specified, it is used for character-wise When optional predicate is specified, it is used for character-wise
comparison. comparison.
\param Input An input sequence \param Input An input sequence
\param Test A test sequence \param Test A test sequence
@ -275,7 +275,7 @@ namespace boost {
//! 'Equals' predicate //! 'Equals' predicate
/*! /*!
\overload \overload
*/ */
template<typename Collection1T, typename Collection2T> template<typename Collection1T, typename Collection2T>
inline bool equals( inline bool equals(

4
include/boost/algorithm/string/predicate_facade.hpp
View File

@ -24,12 +24,12 @@ namespace boost {
// predicate facade ------------------------------------------------------// // predicate facade ------------------------------------------------------//
//! Predicate facade //! Predicate facade
/*! /*!
This class allows to recognize classification This class allows to recognize classification
predicates, so that they can be combined using predicates, so that they can be combined using
composition operators. composition operators.
Every classification predicate must be derived from this class. Every classification predicate must be derived from this class.
*/ */
template<typename Derived> template<typename Derived>
struct predicate_facade {}; struct predicate_facade {};

102
include/boost/algorithm/string/regex.hpp
View File

@ -30,7 +30,7 @@ namespace boost {
//! Find regex algorithm //! Find regex algorithm
/*! /*!
Search for a subsequence matching the given regex in the input. Search for a substring matching the given regex in the input.
\param Input A container which will be searched. \param Input A container which will be searched.
\param Rx A regular expression \param Rx A regular expression
@ -60,15 +60,18 @@ namespace boost {
//! Replace regex algorithm //! Replace regex algorithm
/*! /*!
Search for a subsequence matching given regex and format it with Search for a substring matching given regex and format it with
the specified format. The result is copied to the given output iterator. the specified format.
The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Rx A regular expression \param Rx A regular expression
\param Format Regex format definition \param Format Regex format definition
\param Flags Regex options \param Flags Regex options
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -92,14 +95,7 @@ namespace boost {
//! Replace regex algorithm //! Replace regex algorithm
/*! /*!
Search for a subsequence matching given regex and format it with \overload
the specified format. The result is a modified copy of the input.
\param Input An input sequence
\param Rx A regular expression
\param Format Regex format definition
\param Flags Regex options
\return A modified copy of the input
*/ */
template< template<
typename SequenceT, typename SequenceT,
@ -120,10 +116,10 @@ namespace boost {
//! Replace regex algorithm //! Replace regex algorithm
/*! /*!
Search for a subsequence matching given regex and format it with Search for a substring matching given regex and format it with
the specified format. The input sequence is modified in-place. the specified format. The input string is modified in-place.
\param Input An input sequence \param Input An input string
\param Rx A regular expression \param Rx A regular expression
\param Format Regex format definition \param Format Regex format definition
\param Flags Regex options \param Flags Regex options
@ -149,15 +145,17 @@ namespace boost {
//! Replace all regex algorithm //! Replace all regex algorithm
/*! /*!
Format all subsequences, matching given regex, with the specified format. Format all substrings, matching given regex, with the specified format.
The result is copied to the given output iterator. The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Rx A regular expression \param Rx A regular expression
\param Format Regex format definition \param Format Regex format definition
\param Flags Regex options \param Flags Regex options
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -181,14 +179,7 @@ namespace boost {
//! Replace all regex algorithm //! Replace all regex algorithm
/*! /*!
Format all subsequences, mathing given regex, with the specified format. \overload
The result is a modified copy of the input.
\param Input An input sequence
\param Rx A regular expression
\param Format Regex format definition
\param Flags Regex options
\return A modified copy of the input
*/ */
template< template<
typename SequenceT, typename SequenceT,
@ -209,10 +200,10 @@ namespace boost {
//! Replace all regex algorithm //! Replace all regex algorithm
/*! /*!
Format all subsequences, matching given regex, with the specified format. Format all substrings, matching given regex, with the specified format.
The input sequence is modified in-place. The input string is modified in-place.
\param Input An input sequence \param Input An input string
\param Rx A regular expression \param Rx A regular expression
\param Format Regex format definition \param Format Regex format definition
\param Flags Regex options \param Flags Regex options
@ -238,14 +229,16 @@ namespace boost {
//! Erase regex algorithm //! Erase regex algorithm
/*! /*!
Remove a subsequence matching given regex from the input. Remove a substring matching given regex from the input.
The result is copied to the given output iterator. The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Rx A regular expression \param Rx A regular expression
\param Flags Regex options \param Flags Regex options
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -267,13 +260,7 @@ namespace boost {
//! Erase regex algorithm //! Erase regex algorithm
/*! /*!
Remove a subsequence matching given regex from the input. \overload
The result is a modified copy of the input.
\param Input An input sequence
\param Rx A regular expression
\param Flags Regex options
\return A modified copy of the input
*/ */
template< template<
typename SequenceT, typename SequenceT,
@ -292,10 +279,10 @@ namespace boost {
//! Erase regex algorithm //! Erase regex algorithm
/*! /*!
Remove a subsequence matching given regex from the input. Remove a substring matching given regex from the input.
The input sequence is modified in-place. The input string is modified in-place.
\param Input An input sequence \param Input An input string
\param Rx A regular expression \param Rx A regular expression
\param Flags Regex options \param Flags Regex options
*/ */
@ -318,14 +305,17 @@ namespace boost {
//! Erase all regex algorithm //! Erase all regex algorithm
/*! /*!
Erase all subsequences, matching given regex, from the input. Erase all substrings, matching given regex, from the input.
The result is copied to the given output iterator. The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Rx A regular expression \param Rx A regular expression
\param Flags Regex options \param Flags Regex options
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -347,13 +337,7 @@ namespace boost {
//! Erase all regex algorithm //! Erase all regex algorithm
/*! /*!
Erase all subsequences, matching given regex, from the input. \overload
The result is a modified copy of the input.
\param Input An input sequence
\param Rx A regular expression
\param Flags Regex options
\return A modified copy of the input
*/ */
template< template<
typename SequenceT, typename SequenceT,
@ -372,10 +356,10 @@ namespace boost {
//! Erase all regex algorithm //! Erase all regex algorithm
/*! /*!
Erase all subsequences, matching given regex, from the input. Erase all substrings, matching given regex, from the input.
The input sequence is modified in-place. The input string is modified in-place.
\param Input An input sequence \param Input An input string
\param Rx A regular expression \param Rx A regular expression
\param Flags Regex options \param Flags Regex options
*/ */

380
include/boost/algorithm/string/replace.hpp
View File

@ -30,14 +30,16 @@ namespace boost {
//! Replace range algorithm //! Replace range algorithm
/*! /*!
Substitute the given range in the input sequence with the Replace the given range in the input string.
format sequence. The result is copied to the given output iterator. The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param SearchRange A range in the input to be substituted \param SearchRange A range in the input to be substituted
\param Format A substitute sequence \param Format A substitute string
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -60,13 +62,7 @@ namespace boost {
//! Replace range algorithm //! Replace range algorithm
/*! /*!
Substitute a given range in the input sequence with the \overload
format sequence. The result is a modified copy of the input.
\param Input An input sequence
\param SearchRange A range in the input to be substituted
\param Format A substitute sequence
\return A modified copy of the input
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
inline SequenceT replace_range_copy( inline SequenceT replace_range_copy(
@ -84,12 +80,12 @@ namespace boost {
//! Replace range algorithm //! Replace range algorithm
/*! /*!
Substitute a given range in the input sequence with the Replace the given range in the input string.
format sequence. The input sequence is modified in-place. The input sequence is modified in-place.
\param Input An input sequence \param Input An input string
\param SearchRange A range in the input to be substituted \param SearchRange A range in the input to be substituted
\param Format A substitute sequence \param Format A substitute string
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
inline void replace_range( inline void replace_range(
@ -109,14 +105,17 @@ namespace boost {
//! Replace first algorithm //! Replace first algorithm
/*! /*!
Substitute a first match of the search sequence in the input Replace the first match of the search string in the input
with the format sequence. The result is copied to the given output iterator. with the format string.
The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Format A substitute sequence \param Format A substitute string
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -138,13 +137,7 @@ namespace boost {
//! Replace first algorithm //! Replace first algorithm
/*! /*!
Substitute a first match of the search sequence in the input \overload
with the format sequence. The result is a modified copy of the input.
\param Input An input sequence
\param Search A string to be searched for.
\param Format A substitute sequence
\return A modified copy of the input
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Collection1T, typename Collection2T>
inline SequenceT replace_first_copy( inline SequenceT replace_first_copy(
@ -160,12 +153,12 @@ namespace boost {
//! Replace first algorithm //! Replace first algorithm
/*! /*!
Substitute a first match of the search sequence in the input replace the first match of the search string in the input
with the format sequence. The input sequence is modified in-place. with the format string. The input sequence is modified in-place.
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Format A substitute sequence \param Format A substitute string
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Collection1T, typename Collection2T>
inline void replace_first( inline void replace_first(
@ -183,16 +176,19 @@ namespace boost {
//! Replace first algorithm ( case insensitive ) //! Replace first algorithm ( case insensitive )
/*! /*!
Substitute a first match of the search sequence in the input Replace the first match of the search string in the input
with the format sequence. The result is a modified copy of the input. with the format string.
The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
Searching is case insensitive. Searching is case insensitive.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Format A substitute sequence \param Format A substitute string
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
\return A modified copy of the input \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -213,17 +209,9 @@ namespace boost {
const_formatter(Format) ); const_formatter(Format) );
} }
//! Replace first algorithm ( case insensitive ) //! Replace first algorithm ( case insensitive )
/*! /*!
Substitute a first match of the search sequence in the input \overload
with the format sequence. The result is copied to the given output iterator.
Searching is case insensitive.
\param Input An input sequence
\param Search A string to be searched for.
\param Format A substitute sequence
\param Loc a locale used for case insensitive comparison
\return An output iterator pointing just after last inserted character
*/ */
template<typename SequenceT, typename Collection2T, typename Collection1T> template<typename SequenceT, typename Collection2T, typename Collection1T>
inline SequenceT ireplace_first_copy( inline SequenceT ireplace_first_copy(
@ -240,13 +228,13 @@ namespace boost {
//! Replace first algorithm ( case insensitive ) //! Replace first algorithm ( case insensitive )
/*! /*!
Substitute a first match of the search sequence in the input Replace the first match of the search string in the input
with the format sequence. Input sequence is modified in-place. with the format string. Input sequence is modified in-place.
Searching is case insensitive. Searching is case insensitive.
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Format A substitute sequence \param Format A substitute string
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Collection1T, typename Collection2T>
@ -266,14 +254,17 @@ namespace boost {
//! Replace last algorithm //! Replace last algorithm
/*! /*!
Substitute a last match of the search sequence in the input Replace the last match of the search string in the input
with the format sequence. The result is copied to the given output iterator. with the format string.
The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Format A substitute sequence \param Format A substitute string
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -295,13 +286,7 @@ namespace boost {
//! Replace last algorithm //! Replace last algorithm
/*! /*!
Substitute a last match of the search sequence in the input \overload
with the format sequence. The result is a modified copy of the input.
\param Input An input sequence
\param Search A string to be searched for.
\param Format A substitute sequence
\return A modified copy of the input
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Collection1T, typename Collection2T>
inline SequenceT replace_last_copy( inline SequenceT replace_last_copy(
@ -317,12 +302,12 @@ namespace boost {
//! Replace last algorithm //! Replace last algorithm
/*! /*!
Substitute a last match of the search sequence in the input Replace the last match of the search string in the input
with the format sequence. Input sequence is modified in-place. with the format string. Input sequence is modified in-place.
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Format A substitute sequence \param Format A substitute string
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Collection1T, typename Collection2T>
inline void replace_last( inline void replace_last(
@ -340,16 +325,19 @@ namespace boost {
//! Replace last algorithm ( case insensitive ) //! Replace last algorithm ( case insensitive )
/*! /*!
Substitute a last match of the search sequence in the input Replace the last match of the search string in the input
with the format sequence. The result is copied to the given output iterator. with the format string.
The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
Searching is case insensitive. Searching is case insensitive.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Format A substitute sequence \param Format A substitute string
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -372,15 +360,7 @@ namespace boost {
//! Replace last algorithm ( case insensitive ) //! Replace last algorithm ( case insensitive )
/*! /*!
Substitute a last match of the search sequence in the input \overload
with the format sequence. The result is a modified copy of the input.
Searching is case insensitive.
\param Input An input sequence
\param Search A string to be searched for.
\param Format A substitute sequence
\param Loc a locale used for case insensitive comparison
\return A modified copy of the input
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Collection1T, typename Collection2T>
inline SequenceT ireplace_last_copy( inline SequenceT ireplace_last_copy(
@ -397,13 +377,13 @@ namespace boost {
//! Replace last algorithm ( case insensitive ) //! Replace last algorithm ( case insensitive )
/*! /*!
Substitute a last match of the search sequence in the input Replace the last match of the search string in the input
with the format sequence.The input sequence is modified in-place. with the format string.The input sequence is modified in-place.
Searching is case insensitive. Searching is case insensitive.
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Format A substitute sequence \param Format A substitute string
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
\return A reference to the modified input \return A reference to the modified input
*/ */
@ -424,15 +404,18 @@ namespace boost {
//! Replace nth algorithm //! Replace nth algorithm
/*! /*!
Substitute an Nth match of the search sequence in the input Replace an Nth (zero-indexed) match of the search string in the input
with the format sequence. The result is copied to the given output iterator. with the format string.
The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Nth An index of the match to be replaced. The index is 0-based. \param Nth An index of the match to be replaced. The index is 0-based.
\param Format A substitute sequence \param Format A substitute string
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -455,14 +438,7 @@ namespace boost {
//! Replace nth algorithm //! Replace nth algorithm
/*! /*!
Substitute an Nth match of the search sequence in the input \overload
with the format sequence. The result is a modified copy of the input.
\param Input An input sequence
\param Search A string to be searched for.
\param Nth An index of the match to be replaced. The index is 0-based.
\param Format A substitute sequence
\return A modified copy of the input
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Collection1T, typename Collection2T>
inline SequenceT replace_nth_copy( inline SequenceT replace_nth_copy(
@ -479,13 +455,13 @@ namespace boost {
//! Replace nth algorithm //! Replace nth algorithm
/*! /*!
Substitute an Nth match of the search sequence in the input Replace an Nth (zero-indexed) match of the search string in the input
with the format sequence. Input sequence is modified in-place. with the format string. Input sequence is modified in-place.
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Nth An index of the match to be replaced. The index is 0-based. \param Nth An index of the match to be replaced. The index is 0-based.
\param Format A substitute sequence \param Format A substitute string
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Collection1T, typename Collection2T>
inline void replace_nth( inline void replace_nth(
@ -504,17 +480,20 @@ namespace boost {
//! Replace nth algorithm ( case insensitive ) //! Replace nth algorithm ( case insensitive )
/*! /*!
Substitute an Nth match of the search sequence in the input Replace an Nth (zero-indexed) match of the search string in the input
with the format sequence. The result is copied to the given output iterator. with the format string.
The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
Searching is case insensitive. Searching is case insensitive.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Nth An index of the match to be replaced. The index is 0-based. \param Nth An index of the match to be replaced. The index is 0-based.
\param Format A substitute sequence \param Format A substitute string
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -538,16 +517,7 @@ namespace boost {
//! Replace nth algorithm ( case insensitive ) //! Replace nth algorithm ( case insensitive )
/*! /*!
Substitute an Nth match of the search sequence in the input \overload
with the format sequence. The result is a modified copy of the input.
Searching is case insensitive.
\param Input An input sequence
\param Search A string to be searched for.
\param Nth An index of the match to be replaced. The index is 0-based.
\param Format A substitute sequence
\param Loc a locale used for case insensitive comparison
\return A modified copy of the input
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Collection1T, typename Collection2T>
inline SequenceT ireplace_nth_copy( inline SequenceT ireplace_nth_copy(
@ -565,14 +535,14 @@ namespace boost {
//! Replace nth algorithm ( case insensitive ) //! Replace nth algorithm ( case insensitive )
/*! /*!
Substitute an Nth match of the search sequence in the input Replace an Nth (zero-indexed) match of the search string in the input
with the format sequence. Input sequence is modified in-place. with the format string. Input sequence is modified in-place.
Searching is case insensitive. Searching is case insensitive.
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Nth An index of the match to be replaced. The index is 0-based. \param Nth An index of the match to be replaced. The index is 0-based.
\param Format A substitute sequence \param Format A substitute string
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Collection1T, typename Collection2T>
@ -593,14 +563,17 @@ namespace boost {
//! Replace all algorithm //! Replace all algorithm
/*! /*!
Substitute all occurrences of the search sequence in the input Replace all occurrences of the search string in the input
with the format sequence. The result is copied to the given output iterator. with the format string.
The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Format A substitute sequence \param Format A substitute string
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -622,13 +595,7 @@ namespace boost {
//! Replace all algorithm //! Replace all algorithm
/*! /*!
Substitute all occurrences of the search sequence in the input \overload
with the format sequence. The result is a modified copy of the input.
\param Input An input sequence
\param Search A string to be searched for.
\param Format A substitute sequence
\return A modified copy of the input
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Collection1T, typename Collection2T>
inline SequenceT replace_all_copy( inline SequenceT replace_all_copy(
@ -644,12 +611,12 @@ namespace boost {
//! Replace all algorithm //! Replace all algorithm
/*! /*!
Substitute all occurrences of the search sequence in the input Replace all occurrences of the search string in the input
with the format sequence. The input sequence is modified in-place. with the format string. The input sequence is modified in-place.
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Format A substitute sequence \param Format A substitute string
\return A reference to the modified input \return A reference to the modified input
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Collection1T, typename Collection2T>
@ -668,16 +635,19 @@ namespace boost {
//! Replace all algorithm ( case insensitive ) //! Replace all algorithm ( case insensitive )
/*! /*!
Substitute all occurrences of the search sequence in the input Replace all occurrences of the search string in the input
with the format sequence. The result is copied to the given output iterator. with the format string.
The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
Searching is case insensitive. Searching is case insensitive.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Format A substitute sequence \param Format A substitute string
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -700,15 +670,7 @@ namespace boost {
//! Replace all algorithm ( case insensitive ) //! Replace all algorithm ( case insensitive )
/*! /*!
Substitute all occurrences of the search sequence in the input \overload
with the format sequence. The result is a modified copy of the input.
Searching is case insensitive.
\param Input An input sequence
\param Search A string to be searched for.
\param Format A substitute sequence
\param Loc a locale used for case insensitive comparison
\return A modified copy of the input
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Collection1T, typename Collection2T>
inline SequenceT ireplace_all_copy( inline SequenceT ireplace_all_copy(
@ -725,13 +687,13 @@ namespace boost {
//! Replace all algorithm ( case insensitive ) //! Replace all algorithm ( case insensitive )
/*! /*!
Substitute all occurrences of the search sequence in the input Replace all occurrences of the search string in the input
with the format sequence.The input sequence is modified in-place. with the format string.The input sequence is modified in-place.
Searching is case insensitive. Searching is case insensitive.
\param Input An input sequence \param Input An input string
\param Search A string to be searched for. \param Search A string to be searched for
\param Format A substitute sequence \param Format A substitute string
\param Loc a locale used for case insensitive comparison \param Loc a locale used for case insensitive comparison
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Collection1T, typename Collection2T>
@ -751,16 +713,19 @@ namespace boost {
//! Replace head algorithm //! Replace head algorithm
/*! /*!
Replace the head of the input with the given format sequence. Replace the head of the input with the given format string.
Head is a prefix of a seqence of given size. Head is a prefix of a string of given size.
If the sequence is shorter then required, whole sequence if If the sequence is shorter then required, whole string if
considered to be the head. The result is copied to the given output iterator. considered to be the head.
The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param N A length of the head \param N A length of the head
\param Format A substitute sequence \param Format A substitute string
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -781,15 +746,7 @@ namespace boost {
//! Replace head algorithm //! Replace head algorithm
/*! /*!
Replace the head of the input with the given format sequence. \overload
Head is a prefix of a seqence of given size.
If the sequence is shorter then required, whole sequence if
considered to be the head. The result is a modified copy of the input.
\param Input An input sequence
\param N A length of the head
\param Format A substitute sequence
\return A modified copy of the input
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
inline SequenceT replace_head_copy( inline SequenceT replace_head_copy(
@ -805,14 +762,14 @@ namespace boost {
//! Replace head algorithm //! Replace head algorithm
/*! /*!
Replace the head of the input with the given format sequence. Replace the head of the input with the given format string.
Head is a prefix of a seqence of given size. Head is a prefix of a string of given size.
If the sequence is shorter then required, whole sequence if If the sequence is shorter then required, whole sequence if
considered to be the head. The input sequence is modified in-place. considered to be the head. The input sequence is modified in-place.
\param Input An input sequence \param Input An input string
\param N A length of the head \param N A length of the head
\param Format A substitute sequence \param Format A substitute string
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
inline void replace_head( inline void replace_head(
@ -830,16 +787,19 @@ namespace boost {
//! Replace tail algorithm //! Replace tail algorithm
/*! /*!
Replace the tail of the input with the given format sequence. Replace the tail of the input with the given format string.
Tail is a suffix of a seqence of given size. Tail is a suffix of a string of given size.
If the sequence is shorter then required, whole sequence if If the sequence is shorter then required, whole string if
considered to be the tail. The result is copied to the given output iterator. considered to be the tail.
The result is a modified copy of the input. It is returned as a sequence
or copied to an output iterator.
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input sequence \param Input An input string
\param N A length of the head \param N A length of the head
\param Format A substitute sequence \param Format A substitute string
\return An output iterator pointing just after last inserted character \return An output iterator pointing just after last inserted character or
a modified copy of the input
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
@ -860,15 +820,7 @@ namespace boost {
//! Replace tail algorithm //! Replace tail algorithm
/*! /*!
Replace the tail of the input with the given format sequence. \overload
Tail is a suffix of a seqence of given size.
If the sequence is shorter then required, whole sequence is
considered to be the tail. The result is a modified copy of the input.
\param Input An input sequence
\param N A length of the head
\param Format A substitute sequence
\return A modified copy of the input
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
inline SequenceT replace_tail_copy( inline SequenceT replace_tail_copy(
@ -885,13 +837,13 @@ namespace boost {
//! Replace tail algorithm //! Replace tail algorithm
/*! /*!
Replace the tail of the input with the given format sequence. Replace the tail of the input with the given format sequence.
Tail is a suffix of a seqence of given size. Tail is a suffix of a string of given size.
If the sequence is shorter then required, whole sequence is If the sequence is shorter then required, whole string is
considered to be the tail. The input sequence is modified in-place. considered to be the tail. The input sequence is modified in-place.
\param Input An input sequence \param Input An input string
\param N A length of the head \param N A length of the head
\param Format A substitute sequence \param Format A substitute string
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename CollectionT>
inline void replace_tail( inline void replace_tail(

44
include/boost/algorithm/string/trim.hpp
View File

@ -38,15 +38,15 @@ namespace boost {
/*! /*!
Remove all leading spaces from the input. Supplied predicate Remove all leading spaces from the input. Supplied predicate
is used to determine which character is a space. is used to determine which character is a space.
The result is a trimmed copy if the input. It is returned as a sequence The result is a trimmed copy of the input. It is returned as a sequence
or copied to an output iterator or copied to an output iterator
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input collection \param Input An input collection
\param IsSpace An unary predicate identifying spaces \param IsSpace An unary predicate identifying spaces
\return \return
An output iterator pointing just after last inserted character or An output iterator pointing just after last inserted character or
a copy of the input a copy of the input
*/ */
template<typename OutputIteratorT, typename CollectionT, typename PredicateT> template<typename OutputIteratorT, typename CollectionT, typename PredicateT>
inline OutputIteratorT trim_left_copy_if( inline OutputIteratorT trim_left_copy_if(
@ -67,8 +67,8 @@ namespace boost {
//! Left trim - parametric //! Left trim - parametric
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename PredicateT> template<typename SequenceT, typename PredicateT>
inline SequenceT trim_left_copy_if(const SequenceT& Input, PredicateT IsSpace) inline SequenceT trim_left_copy_if(const SequenceT& Input, PredicateT IsSpace)
{ {
@ -83,11 +83,11 @@ namespace boost {
//! Left trim - parametric //! Left trim - parametric
/*! /*!
Remove all leading spaces from the input. Remove all leading spaces from the input.
The result is a trimmed copy if the input. The result is a trimmed copy of the input.
\param Input An input sequence \param Input An input sequence
\param Loc a locale used for 'space' classification \param Loc a locale used for 'space' classification
\return A trimmed copy if the input \return A trimmed copy of the input
*/ */
template<typename SequenceT> template<typename SequenceT>
inline SequenceT trim_left_copy(const SequenceT& Input, const std::locale& Loc=std::locale()) inline SequenceT trim_left_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
@ -140,15 +140,15 @@ namespace boost {
/*! /*!
Remove all trailing spaces from the input. Supplied predicate Remove all trailing spaces from the input. Supplied predicate
is used to determine which character is a space. is used to determine which character is a space.
The result is a trimmed copy if the input. It is returned as a sequence The result is a trimmed copy of the input. It is returned as a sequence
or copied to an output iterator or copied to an output iterator
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input collection \param Input An input collection
\param IsSpace An unary predicate identifying spaces \param IsSpace An unary predicate identifying spaces
\return \return
An output iterator pointing just after last inserted character or An output iterator pointing just after last inserted character or
a copy of the input a copy of the input
*/ */
template<typename OutputIteratorT, typename CollectionT, typename PredicateT> template<typename OutputIteratorT, typename CollectionT, typename PredicateT>
inline OutputIteratorT trim_right_copy_if( inline OutputIteratorT trim_right_copy_if(
@ -169,7 +169,7 @@ namespace boost {
//! Right trim - parametric //! Right trim - parametric
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename PredicateT> template<typename SequenceT, typename PredicateT>
inline SequenceT trim_right_copy_if(const SequenceT& Input, PredicateT IsSpace) inline SequenceT trim_right_copy_if(const SequenceT& Input, PredicateT IsSpace)
@ -186,11 +186,11 @@ namespace boost {
//! Right trim //! Right trim
/*! /*!
Remove all trailing spaces from the input. Remove all trailing spaces from the input.
The result is a trimmed copy if the input The result is a trimmed copy of the input
\param Input An input sequence \param Input An input sequence
\param Loc A locale used for 'space' classification \param Loc A locale used for 'space' classification
\return A trimmed copy if the input \return A trimmed copy of the input
*/ */
template<typename SequenceT> template<typename SequenceT>
inline SequenceT trim_right_copy(const SequenceT& Input, const std::locale& Loc=std::locale()) inline SequenceT trim_right_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
@ -246,15 +246,15 @@ namespace boost {
/*! /*!
Remove all trailing and leading spaces from the input. Remove all trailing and leading spaces from the input.
Supplied predicate is used to determine which character is a space. Supplied predicate is used to determine which character is a space.
The result is a trimmed copy if the input. It is returned as a sequence The result is a trimmed copy of the input. It is returned as a sequence
or copied to an output iterator or copied to an output iterator
\param Output A output iterator to which the result will be copied \param Output A output iterator to which the result will be copied
\param Input An input collection \param Input An input collection
\param IsSpace An unary predicate identifying spaces \param IsSpace An unary predicate identifying spaces
\return \return
An output iterator pointing just after last inserted character or An output iterator pointing just after last inserted character or
a copy of the input a copy of the input
*/ */
template<typename OutputIteratorT, typename CollectionT, typename PredicateT> template<typename OutputIteratorT, typename CollectionT, typename PredicateT>
inline OutputIteratorT trim_copy_if( inline OutputIteratorT trim_copy_if(
@ -281,7 +281,7 @@ namespace boost {
//! Trim - parametric //! Trim - parametric
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename PredicateT> template<typename SequenceT, typename PredicateT>
inline SequenceT trim_copy_if(const SequenceT& Input, PredicateT IsSpace) inline SequenceT trim_copy_if(const SequenceT& Input, PredicateT IsSpace)
@ -305,11 +305,11 @@ namespace boost {
//! Trim //! Trim
/*! /*!
Remove all leading and trailing spaces from the input. Remove all leading and trailing spaces from the input.
The result is a trimmed copy if the input The result is a trimmed copy of the input
\param Input An input sequence \param Input An input sequence
\param Loc A locale used for 'space' classification \param Loc A locale used for 'space' classification
\return A trimmed copy if the input \return A trimmed copy of the input
*/ */
template<typename SequenceT> template<typename SequenceT>
inline SequenceT trim_copy( const SequenceT& Input, const std::locale& Loc=std::locale() ) inline SequenceT trim_copy( const SequenceT& Input, const std::locale& Loc=std::locale() )