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

Naming convetion changed to follow Boost.Range

Browse Source 
[SVN r28185]
This commit is contained in:
Pavol Droba
2005-04-12 16:50:42 +00:00
parent 8fc117aa7e
commit b0a2a9d3e0
15 changed files with 398 additions and 398 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -39,7 +39,7 @@ namespace boost {
It is returned as a sequence or copied to the output iterator. It is returned as a sequence or copied to the output iterator.
\param Output An output iterator to which the result will be copied \param Output An output iterator to which the result will be copied
\param Input An input collection \param Input An input range
\param Loc A locale used for conversion \param Loc A locale used for conversion
\return \return
An output iterator pointing just after the last inserted character or An output iterator pointing just after the last inserted character or
@ -48,11 +48,11 @@ namespace boost {
\note The second variant of this function provides the strong exception-safety guarantee \note The second variant of this function provides the strong exception-safety guarantee
*/ */
template<typename OutputIteratorT, typename CollectionT> template<typename OutputIteratorT, typename RangeT>
inline OutputIteratorT inline OutputIteratorT
to_lower_copy( to_lower_copy(
OutputIteratorT Output, OutputIteratorT Output,
const CollectionT& Input, const RangeT& Input,
const std::locale& Loc=std::locale()) const std::locale& Loc=std::locale())
{ {
return std::transform( return std::transform(
@ -60,7 +60,7 @@ namespace boost {
end(Input), end(Input),
Output, Output,
detail::to_lowerF< detail::to_lowerF<
typename range_value<CollectionT>::type >(Loc)); typename range_value<RangeT>::type >(Loc));
} }
//! Convert to lower case //! Convert to lower case
@ -88,12 +88,12 @@ namespace boost {
Each element of the input sequence is converted to lower Each element of the input sequence is converted to lower
case. The input sequence is modified in-place. case. The input sequence is modified in-place.
\param Input A collection \param Input A range
\param Loc a locale used for conversion \param Loc a locale used for conversion
*/ */
template<typename MutableCollectionT> template<typename WritableRangeT>
inline void to_lower( inline void to_lower(
MutableCollectionT& Input, WritableRangeT& Input,
const std::locale& Loc=std::locale()) const std::locale& Loc=std::locale())
{ {
std::transform( std::transform(
@ -101,7 +101,7 @@ namespace boost {
end(Input), end(Input),
begin(Input), begin(Input),
detail::to_lowerF< detail::to_lowerF<
typename range_value<MutableCollectionT>::type >(Loc)); typename range_value<WritableRangeT>::type >(Loc));
} }
// to_upper -----------------------------------------------// // to_upper -----------------------------------------------//
@ -113,7 +113,7 @@ namespace boost {
It is returned as a sequence or copied to the output iterator It is returned as a sequence or copied to the output iterator
\param Output An output iterator to which the result will be copied \param Output An output iterator to which the result will be copied
\param Input An input collection \param Input An input range
\param Loc A locale used for conversion \param Loc A locale used for conversion
\return \return
An output iterator pointing just after the last inserted character or An output iterator pointing just after the last inserted character or
@ -121,11 +121,11 @@ namespace boost {
\note The second variant of this function provides the strong exception-safety guarantee \note The second variant of this function provides the strong exception-safety guarantee
*/ */
template<typename OutputIteratorT, typename CollectionT> template<typename OutputIteratorT, typename RangeT>
inline OutputIteratorT inline OutputIteratorT
to_upper_copy( to_upper_copy(
OutputIteratorT Output, OutputIteratorT Output,
const CollectionT& Input, const RangeT& Input,
const std::locale& Loc=std::locale()) const std::locale& Loc=std::locale())
{ {
return std::transform( return std::transform(
@ -133,7 +133,7 @@ namespace boost {
end(Input), end(Input),
Output, Output,
detail::to_upperF< detail::to_upperF<
typename range_value<CollectionT>::type >(Loc)); typename range_value<RangeT>::type >(Loc));
} }
//! Convert to upper case //! Convert to upper case
@ -162,12 +162,12 @@ namespace boost {
Each element of the input sequence is converted to upper Each element of the input sequence is converted to upper
case. The input sequence is modified in-place. case. The input sequence is modified in-place.
\param Input An input collection \param Input An input range
\param Loc a locale used for conversion \param Loc a locale used for conversion
*/ */
template<typename MutableCollectionT> template<typename WritableRangeT>
inline void to_upper( inline void to_upper(
MutableCollectionT& Input, WritableRangeT& Input,
const std::locale& Loc=std::locale()) const std::locale& Loc=std::locale())
{ {
std::transform( std::transform(
@ -175,7 +175,7 @@ namespace boost {
end(Input), end(Input),
begin(Input), begin(Input),
detail::to_upperF< detail::to_upperF<
typename range_value<MutableCollectionT>::type >(Loc)); typename range_value<WritableRangeT>::type >(Loc));
} }
} // namespace algorithm } // namespace algorithm

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

@ -194,13 +194,13 @@ namespace boost {
\param Set A set of characters to be recognized \param Set A set of characters to be recognized
\return An instance of the \c is_any_of predicate \return An instance of the \c is_any_of predicate
*/ */
template<typename ContainerT> template<typename RangeT>
inline detail::is_any_ofF< inline detail::is_any_ofF<
BOOST_STRING_TYPENAME range_value<ContainerT>::type> BOOST_STRING_TYPENAME range_value<RangeT>::type>
is_any_of( const ContainerT& Set ) is_any_of( const RangeT& Set )
{ {
return detail::is_any_ofF< return detail::is_any_ofF<
BOOST_STRING_TYPENAME range_value<ContainerT>::type>(Set); BOOST_STRING_TYPENAME range_value<RangeT>::type>(Set);
} }
//! is_from_range predicate //! is_from_range predicate

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

@ -63,9 +63,9 @@ namespace boost {
template <class Args> struct sig { typedef bool type; }; template <class Args> struct sig { typedef bool type; };
// Constructor // Constructor
template< typename SeqT > template<typename RangeT>
is_any_ofF( const SeqT& Seq ) : is_any_ofF( const RangeT& Range ) :
m_Set( begin(Seq), end(Seq) ) {} m_Set( begin(Range), end(Range) ) {}
// Operation // Operation
template<typename Char2T> template<typename Char2T>

18
include/boost/algorithm/string/detail/formatter.hpp
View File

@ -27,22 +27,22 @@ namespace boost {
// const format functor ----------------------------------------------------// // const format functor ----------------------------------------------------//
// constant format functor // constant format functor
template<typename CollectionT> template<typename RangeT>
struct const_formatF struct const_formatF
{ {
private: private:
typedef BOOST_STRING_TYPENAME typedef BOOST_STRING_TYPENAME
range_const_iterator<CollectionT>::type format_iterator; range_const_iterator<RangeT>::type format_iterator;
typedef iterator_range<format_iterator> result_type; typedef iterator_range<format_iterator> result_type;
public: public:
// Construction // Construction
const_formatF(const CollectionT& Format) : const_formatF(const RangeT& Format) :
m_Format(begin(Format), end(Format)) {} m_Format(begin(Format), end(Format)) {}
// Operation // Operation
template<typename Collection2T> template<typename Range2T>
const result_type& operator()(const Collection2T&) const const result_type& operator()(const Range2T&) const
{ {
return m_Format; return m_Format;
} }
@ -54,14 +54,14 @@ namespace boost {
// identity format functor ----------------------------------------------------// // identity format functor ----------------------------------------------------//
// identity format functor // identity format functor
template<typename CollectionT> template<typename RangeT>
struct identity_formatF struct identity_formatF
{ {
// Operation // Operation
template< typename Collection2T > template< typename Range2T >
const CollectionT& operator()(const Collection2T& Replace) const const RangeT& operator()(const Range2T& Replace) const
{ {
return CollectionT(begin(Replace), end(Replace)); return RangeT(begin(Replace), end(Replace));
} }
}; };

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

@ -45,13 +45,13 @@ namespace boost {
\note The second variant of this function provides the strong exception-safety guarantee \note The second variant of this function provides the strong exception-safety guarantee
*/ */
template<typename OutputIteratorT, typename CollectionT> template<typename OutputIteratorT, typename RangeT>
inline OutputIteratorT erase_range_copy( inline OutputIteratorT erase_range_copy(
OutputIteratorT Output, OutputIteratorT Output,
const CollectionT& Input, const RangeT& Input,
const iterator_range< const iterator_range<
BOOST_STRING_TYPENAME BOOST_STRING_TYPENAME
range_const_iterator<CollectionT>::type>& SearchRange ) range_const_iterator<RangeT>::type>& SearchRange )
{ {
return find_format_copy( return find_format_copy(
Output, Output,
@ -116,12 +116,12 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T> typename Range2T>
inline OutputIteratorT erase_first_copy( inline OutputIteratorT erase_first_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
const Collection2T& Search ) const Range2T& Search )
{ {
return find_format_copy( return find_format_copy(
Output, Output,
@ -134,10 +134,10 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline SequenceT erase_first_copy( inline SequenceT erase_first_copy(
const SequenceT& Input, const SequenceT& Input,
const CollectionT& Search ) const RangeT& Search )
{ {
return find_format_copy( return find_format_copy(
Input, Input,
@ -153,10 +153,10 @@ namespace boost {
\param Input An input string \param Input An input string
\param Search A substring to be searched for. \param Search A substring to be searched for.
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline void erase_first( inline void erase_first(
SequenceT& Input, SequenceT& Input,
const CollectionT& Search ) const RangeT& Search )
{ {
find_format( find_format(
Input, Input,
@ -184,12 +184,12 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T> typename Range2T>
inline OutputIteratorT ierase_first_copy( inline OutputIteratorT ierase_first_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
const Collection2T& Search, const Range2T& Search,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
return find_format_copy( return find_format_copy(
@ -203,10 +203,10 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline SequenceT ierase_first_copy( inline SequenceT ierase_first_copy(
const SequenceT& Input, const SequenceT& Input,
const CollectionT& Search, const RangeT& Search,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
return find_format_copy( return find_format_copy(
@ -224,10 +224,10 @@ namespace boost {
\param Search A substring to be searched for \param Search A substring 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 RangeT>
inline void ierase_first( inline void ierase_first(
SequenceT& Input, SequenceT& Input,
const CollectionT& Search, const RangeT& Search,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
find_format( find_format(
@ -254,12 +254,12 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T> typename Range2T>
inline OutputIteratorT erase_last_copy( inline OutputIteratorT erase_last_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
const Collection2T& Search ) const Range2T& Search )
{ {
return find_format_copy( return find_format_copy(
Output, Output,
@ -272,10 +272,10 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline SequenceT erase_last_copy( inline SequenceT erase_last_copy(
const SequenceT& Input, const SequenceT& Input,
const CollectionT& Search ) const RangeT& Search )
{ {
return find_format_copy( return find_format_copy(
Input, Input,
@ -291,10 +291,10 @@ namespace boost {
\param Input An input string \param Input An input string
\param Search A substring to be searched for \param Search A substring to be searched for
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline void erase_last( inline void erase_last(
SequenceT& Input, SequenceT& Input,
const CollectionT& Search ) const RangeT& Search )
{ {
find_format( find_format(
Input, Input,
@ -322,12 +322,12 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T> typename Range2T>
inline OutputIteratorT ierase_last_copy( inline OutputIteratorT ierase_last_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
const Collection2T& Search, const Range2T& Search,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
return find_format_copy( return find_format_copy(
@ -341,10 +341,10 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline SequenceT ierase_last_copy( inline SequenceT ierase_last_copy(
const SequenceT& Input, const SequenceT& Input,
const CollectionT& Search, const RangeT& Search,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
return find_format_copy( return find_format_copy(
@ -362,10 +362,10 @@ namespace boost {
\param Search A substring to be searched for \param Search A substring 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 RangeT>
inline void ierase_last( inline void ierase_last(
SequenceT& Input, SequenceT& Input,
const CollectionT& Search, const RangeT& Search,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
find_format( find_format(
@ -394,12 +394,12 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T> typename Range2T>
inline OutputIteratorT erase_nth_copy( inline OutputIteratorT erase_nth_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
const Collection2T& Search, const Range2T& Search,
unsigned int Nth ) unsigned int Nth )
{ {
return find_format_copy( return find_format_copy(
@ -413,10 +413,10 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline SequenceT erase_nth_copy( inline SequenceT erase_nth_copy(
const SequenceT& Input, const SequenceT& Input,
const CollectionT& Search, const RangeT& Search,
unsigned int Nth ) unsigned int Nth )
{ {
return find_format_copy( return find_format_copy(
@ -434,10 +434,10 @@ namespace boost {
\param Search A substring to be searched for. \param Search A substring 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.
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline void erase_nth( inline void erase_nth(
SequenceT& Input, SequenceT& Input,
const CollectionT& Search, const RangeT& Search,
unsigned int Nth ) unsigned int Nth )
{ {
find_format( find_format(
@ -467,12 +467,12 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T> typename Range2T>
inline OutputIteratorT ierase_nth_copy( inline OutputIteratorT ierase_nth_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
const Collection2T& Search, const Range2T& Search,
unsigned int Nth, unsigned int Nth,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
@ -487,10 +487,10 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline SequenceT ierase_nth_copy( inline SequenceT ierase_nth_copy(
const SequenceT& Input, const SequenceT& Input,
const CollectionT& Search, const RangeT& Search,
unsigned int Nth, unsigned int Nth,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
@ -510,10 +510,10 @@ namespace boost {
\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
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline void ierase_nth( inline void ierase_nth(
SequenceT& Input, SequenceT& Input,
const CollectionT& Search, const RangeT& Search,
unsigned int Nth, unsigned int Nth,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
@ -543,12 +543,12 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T> typename Range2T>
inline OutputIteratorT erase_all_copy( inline OutputIteratorT erase_all_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
const Collection2T& Search ) const Range2T& Search )
{ {
return find_format_all_copy( return find_format_all_copy(
Output, Output,
@ -561,10 +561,10 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline SequenceT erase_all_copy( inline SequenceT erase_all_copy(
const SequenceT& Input, const SequenceT& Input,
const CollectionT& Search ) const RangeT& Search )
{ {
return find_format_all_copy( return find_format_all_copy(
Input, Input,
@ -580,10 +580,10 @@ namespace boost {
\param Input An input string \param Input An input string
\param Search A substring to be searched for. \param Search A substring to be searched for.
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline void erase_all( inline void erase_all(
SequenceT& Input, SequenceT& Input,
const CollectionT& Search ) const RangeT& Search )
{ {
find_format_all( find_format_all(
Input, Input,
@ -611,12 +611,12 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T> typename Range2T>
inline OutputIteratorT ierase_all_copy( inline OutputIteratorT ierase_all_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
const Collection2T& Search, const Range2T& Search,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
return find_format_all_copy( return find_format_all_copy(
@ -630,10 +630,10 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline SequenceT ierase_all_copy( inline SequenceT ierase_all_copy(
const SequenceT& Input, const SequenceT& Input,
const CollectionT& Search, const RangeT& Search,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
return find_format_all_copy( return find_format_all_copy(
@ -651,10 +651,10 @@ namespace boost {
\param Search A substring to be searched for. \param Search A substring 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 RangeT>
inline void ierase_all( inline void ierase_all(
SequenceT& Input, SequenceT& Input,
const CollectionT& Search, const RangeT& Search,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
find_format_all( find_format_all(
@ -683,10 +683,10 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename CollectionT> typename RangeT>
inline OutputIteratorT erase_head_copy( inline OutputIteratorT erase_head_copy(
OutputIteratorT Output, OutputIteratorT Output,
const CollectionT& Input, const RangeT& Input,
unsigned int N ) unsigned int N )
{ {
return find_format_copy( return find_format_copy(
@ -751,10 +751,10 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename CollectionT> typename RangeT>
inline OutputIteratorT erase_tail_copy( inline OutputIteratorT erase_tail_copy(
OutputIteratorT Output, OutputIteratorT Output,
const CollectionT& Input, const RangeT& Input,
unsigned int N ) unsigned int N )
{ {
return find_format_copy( return find_format_copy(

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

@ -42,15 +42,15 @@ namespace boost {
\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.
Returned iterator is either \c CollectionT::iterator or Returned iterator is either \c RangeT::iterator or
\c CollectionT::const_iterator, depending on the constness of \c RangeT::const_iterator, depending on the constness of
the input parameter. the input parameter.
*/ */
template<typename CollectionT, typename FinderT> template<typename RangeT, typename FinderT>
inline iterator_range< inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type> BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
find( find(
CollectionT& Input, RangeT& Input,
FinderT Finder) FinderT Finder)
{ {
return Finder(begin(Input),end(Input)); return Finder(begin(Input),end(Input));
@ -66,18 +66,18 @@ namespace boost {
\param Search A substring to be searched for. \param Search A substring to be searched for.
\return \return
An \c iterator_range delimiting the match. An \c iterator_range delimiting the match.
Returned iterator is either \c CollectionT::iterator or Returned iterator is either \c RangeT::iterator or
\c CollectionT::const_iterator, depending on the constness of \c RangeT::const_iterator, depending on the constness of
the input parameter. the input parameter.
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template<typename Collection1T, typename Collection2T> template<typename Range1T, typename Range2T>
inline iterator_range< inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<Collection1T>::type> BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
find_first( find_first(
Collection1T& Input, Range1T& Input,
const Collection2T& Search) const Range2T& Search)
{ {
return first_finder(Search)( return first_finder(Search)(
begin(Input),end(Input)); begin(Input),end(Input));
@ -93,18 +93,18 @@ namespace boost {
\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.
Returned iterator is either \c Collection1T::iterator or Returned iterator is either \c Range1T::iterator or
\c Collection1T::const_iterator, depending on the constness of \c Range1T::const_iterator, depending on the constness of
the input parameter. the input parameter.
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template<typename Collection1T, typename Collection2T> template<typename Range1T, typename Range2T>
inline iterator_range< inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<Collection1T>::type> BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
ifind_first( ifind_first(
Collection1T& Input, Range1T& Input,
const Collection2T& Search, const Range2T& Search,
const std::locale& Loc=std::locale()) const std::locale& Loc=std::locale())
{ {
return first_finder(Search,is_iequal(Loc))( return first_finder(Search,is_iequal(Loc))(
@ -121,18 +121,18 @@ namespace boost {
\param Search A substring to be searched for. \param Search A substring to be searched for.
\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 Range1T::iterator or
\c Collection1T::const_iterator, depending on the constness of \c Range1T::const_iterator, depending on the constness of
the input parameter. the input parameter.
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template<typename Collection1T, typename Collection2T> template<typename Range1T, typename Range2T>
inline iterator_range< inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<Collection1T>::type> BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
find_last( find_last(
Collection1T& Input, Range1T& Input,
const Collection2T& Search) const Range2T& Search)
{ {
return last_finder(Search)( return last_finder(Search)(
begin(Input),end(Input)); begin(Input),end(Input));
@ -148,18 +148,18 @@ namespace boost {
\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.
Returned iterator is either \c Collection1T::iterator or Returned iterator is either \c Range1T::iterator or
\c Collection1T::const_iterator, depending on the constness of \c Range1T::const_iterator, depending on the constness of
the input parameter. the input parameter.
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template<typename Collection1T, typename Collection2T> template<typename Range1T, typename Range2T>
inline iterator_range< inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<Collection1T>::type> BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
ifind_last( ifind_last(
Collection1T& Input, Range1T& Input,
const Collection2T& Search, const Range2T& Search,
const std::locale& Loc=std::locale()) const std::locale& Loc=std::locale())
{ {
return last_finder(Search, is_iequal(Loc))( return last_finder(Search, is_iequal(Loc))(
@ -178,16 +178,16 @@ namespace boost {
\param Nth An index (zero-indexed) 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 Range1T::iterator or
\c Collection1T::const_iterator, depending on the constness of \c Range1T::const_iterator, depending on the constness of
the input parameter. the input parameter.
*/ */
template<typename Collection1T, typename Collection2T> template<typename Range1T, typename Range2T>
inline iterator_range< inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<Collection1T>::type> BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
find_nth( find_nth(
Collection1T& Input, Range1T& Input,
const Collection2T& Search, const Range2T& Search,
unsigned int Nth) unsigned int Nth)
{ {
return nth_finder(Search,Nth)( return nth_finder(Search,Nth)(
@ -205,19 +205,19 @@ namespace boost {
\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.
Returned iterator is either \c Collection1T::iterator or Returned iterator is either \c Range1T::iterator or
\c Collection1T::const_iterator, depending on the constness of \c Range1T::const_iterator, depending on the constness of
the input parameter. the input parameter.
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template<typename Collection1T, typename Collection2T> template<typename Range1T, typename Range2T>
inline iterator_range< inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<Collection1T>::type> BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
ifind_nth( ifind_nth(
Collection1T& Input, Range1T& Input,
const Collection2T& Search, const Range2T& Search,
unsigned int Nth, unsigned int Nth,
const std::locale& Loc=std::locale()) const std::locale& Loc=std::locale())
{ {
@ -237,17 +237,17 @@ namespace boost {
\param N Length of the head \param N Length of the head
\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 Range1T::iterator or
\c Collection1T::const_iterator, depending on the constness of \c Range1T::const_iterator, depending on the constness of
the input parameter. the input parameter.
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template<typename CollectionT> template<typename RangeT>
inline iterator_range< inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type> BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
find_head( find_head(
CollectionT& Input, RangeT& Input,
unsigned int N) unsigned int N)
{ {
return head_finder(N)( return head_finder(N)(
@ -266,18 +266,18 @@ namespace boost {
\param N Length of the tail \param N Length of the tail
\return \return
An \c iterator_range delimiting the match. An \c iterator_range delimiting the match.
Returned iterator is either \c CollectionT::iterator or Returned iterator is either \c RangeT::iterator or
\c CollectionT::const_iterator, depending on the constness of \c RangeT::const_iterator, depending on the constness of
the input parameter. the input parameter.
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template<typename CollectionT> template<typename RangeT>
inline iterator_range< inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type> BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
find_tail( find_tail(
CollectionT& Input, RangeT& Input,
unsigned int N) unsigned int N)
{ {
return tail_finder(N)( return tail_finder(N)(
@ -297,17 +297,17 @@ namespace boost {
\param eCompress Enable/Disable compressing of adjacent tokens \param eCompress Enable/Disable compressing of adjacent tokens
\return \return
An \c iterator_range delimiting the match. An \c iterator_range delimiting the match.
Returned iterator is either \c CollectionT::iterator or Returned iterator is either \c RangeT::iterator or
\c CollectionT::const_iterator, depending on the constness of \c RangeT::const_iterator, depending on the constness of
the input parameter. the input parameter.
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template<typename CollectionT, typename PredicateT> template<typename RangeT, typename PredicateT>
inline iterator_range< inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type> BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
find_token( find_token(
CollectionT& Input, RangeT& Input,
PredicateT Pred, PredicateT Pred,
token_compress_mode_type eCompress=token_compress_off) token_compress_mode_type eCompress=token_compress_off)
{ {

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

@ -50,23 +50,23 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename CollectionT, typename RangeT,
typename FinderT, typename FinderT,
typename FormatterT> typename FormatterT>
inline OutputIteratorT find_format_copy( inline OutputIteratorT find_format_copy(
OutputIteratorT Output, OutputIteratorT Output,
const CollectionT& Input, const RangeT& Input,
FinderT Finder, FinderT Finder,
FormatterT Formatter ) FormatterT Formatter )
{ {
// Concept check // Concept check
function_requires< function_requires<
FinderConcept<FinderT, FinderConcept<FinderT,
BOOST_STRING_TYPENAME range_const_iterator<CollectionT>::type> >(); BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
function_requires< function_requires<
FormatterConcept< FormatterConcept<
FormatterT, FormatterT,
FinderT,BOOST_STRING_TYPENAME range_const_iterator<CollectionT>::type> >(); FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
return detail::find_format_copy_impl( return detail::find_format_copy_impl(
Output, Output,
@ -161,23 +161,23 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename CollectionT, typename RangeT,
typename FinderT, typename FinderT,
typename FormatterT> typename FormatterT>
inline OutputIteratorT find_format_all_copy( inline OutputIteratorT find_format_all_copy(
OutputIteratorT Output, OutputIteratorT Output,
const CollectionT& Input, const RangeT& Input,
FinderT Finder, FinderT Finder,
FormatterT Formatter) FormatterT Formatter)
{ {
// Concept check // Concept check
function_requires< function_requires<
FinderConcept<FinderT, FinderConcept<FinderT,
BOOST_STRING_TYPENAME range_const_iterator<CollectionT>::type> >(); BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
function_requires< function_requires<
FormatterConcept< FormatterConcept<
FormatterT, FormatterT,
FinderT,BOOST_STRING_TYPENAME range_const_iterator<CollectionT>::type> >(); FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
return detail::find_format_all_copy_impl( return detail::find_format_all_copy_impl(
Output, Output,

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

@ -110,9 +110,9 @@ namespace boost {
Construct new find_iterator for a given finder Construct new find_iterator for a given finder
and a collection. and a collection.
*/ */
template<typename FinderT, typename CollectionT> template<typename FinderT, typename RangeT>
find_iterator( find_iterator(
CollectionT& Col, RangeT& 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)),
@ -178,14 +178,14 @@ namespace boost {
/*! /*!
* Construct a find iterator to iterate through the specified string * Construct a find iterator to iterate through the specified string
*/ */
template<typename CollectionT, typename FinderT> template<typename RangeT, typename FinderT>
inline find_iterator< inline find_iterator<
BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type> BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
make_find_iterator( make_find_iterator(
CollectionT& Collection, RangeT& Collection,
FinderT Finder) FinderT Finder)
{ {
return find_iterator<BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type>( return find_iterator<BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>(
begin(Collection), end(Collection), Finder); begin(Collection), end(Collection), Finder);
} }
@ -273,9 +273,9 @@ namespace boost {
Construct new split_iterator for a given finder Construct new split_iterator for a given finder
and a collection. and a collection.
*/ */
template<typename FinderT, typename CollectionT> template<typename FinderT, typename RangeT>
split_iterator( split_iterator(
CollectionT& Col, RangeT& 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)),
@ -354,14 +354,14 @@ namespace boost {
/*! /*!
* Construct a split iterator to iterate through the specified collection * Construct a split iterator to iterate through the specified collection
*/ */
template<typename CollectionT, typename FinderT> template<typename RangeT, typename FinderT>
inline split_iterator< inline split_iterator<
BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type> BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
make_split_iterator( make_split_iterator(
CollectionT& Collection, RangeT& Collection,
FinderT Finder) FinderT Finder)
{ {
return split_iterator<BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type>( return split_iterator<BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>(
begin(Collection), end(Collection), Finder); begin(Collection), end(Collection), Finder);
} }

22
include/boost/algorithm/string/formatter.hpp
View File

@ -40,11 +40,11 @@ namespace boost {
\param Format A predefined value used as a result for formating \param Format A predefined value used as a result for formating
\return An instance of the \c const_formatter object. \return An instance of the \c const_formatter object.
*/ */
template<typename CollectionT> template<typename RangeT>
inline detail::const_formatF<CollectionT> inline detail::const_formatF<RangeT>
const_formatter(const CollectionT& Format) const_formatter(const RangeT& Format)
{ {
return detail::const_formatF<CollectionT>(Format); return detail::const_formatF<RangeT>(Format);
} }
//! Identity formatter //! Identity formatter
@ -54,11 +54,11 @@ namespace boost {
\return An instance of the \c identity_formatter object. \return An instance of the \c identity_formatter object.
*/ */
template<typename CollectionT> template<typename RangeT>
inline detail::identity_formatF<CollectionT> inline detail::identity_formatF<RangeT>
identity_formatter() identity_formatter()
{ {
return detail::identity_formatF<CollectionT>(); return detail::identity_formatF<RangeT>();
} }
//! Empty formatter //! Empty formatter
@ -70,13 +70,13 @@ namespace boost {
resulting empty_container<>. resulting empty_container<>.
\return An instance of the \c empty_formatter object. \return An instance of the \c empty_formatter object.
*/ */
template<typename CollectionT> template<typename RangeT>
inline detail::empty_formatF< inline detail::empty_formatF<
BOOST_STRING_TYPENAME range_value<CollectionT>::type> BOOST_STRING_TYPENAME range_value<RangeT>::type>
empty_formatter(const CollectionT&) empty_formatter(const RangeT&)
{ {
return detail::empty_formatF< return detail::empty_formatF<
BOOST_STRING_TYPENAME range_value<CollectionT>::type>(); BOOST_STRING_TYPENAME range_value<RangeT>::type>();
} }

16
include/boost/algorithm/string/iter_find.hpp
View File

@ -64,20 +64,20 @@ namespace boost {
*/ */
template< template<
typename SequenceSequenceT, typename SequenceSequenceT,
typename CollectionT, typename RangeT,
typename FinderT > typename FinderT >
inline SequenceSequenceT& inline SequenceSequenceT&
iter_find( iter_find(
SequenceSequenceT& Result, SequenceSequenceT& Result,
CollectionT& Input, RangeT& Input,
FinderT Finder ) FinderT Finder )
{ {
function_requires< function_requires<
FinderConcept<FinderT, FinderConcept<FinderT,
BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type> >(); BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type> >();
typedef BOOST_STRING_TYPENAME typedef BOOST_STRING_TYPENAME
range_result_iterator<CollectionT>::type input_iterator_type; range_result_iterator<RangeT>::type input_iterator_type;
typedef find_iterator<input_iterator_type> find_iterator_type; typedef find_iterator<input_iterator_type> find_iterator_type;
typedef detail::copy_iterator_rangeF< typedef detail::copy_iterator_rangeF<
BOOST_STRING_TYPENAME BOOST_STRING_TYPENAME
@ -131,20 +131,20 @@ namespace boost {
*/ */
template< template<
typename SequenceSequenceT, typename SequenceSequenceT,
typename CollectionT, typename RangeT,
typename FinderT > typename FinderT >
inline SequenceSequenceT& inline SequenceSequenceT&
iter_split( iter_split(
SequenceSequenceT& Result, SequenceSequenceT& Result,
CollectionT& Input, RangeT& Input,
FinderT Finder ) FinderT Finder )
{ {
function_requires< function_requires<
FinderConcept<FinderT, FinderConcept<FinderT,
BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type> >(); BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type> >();
typedef BOOST_STRING_TYPENAME typedef BOOST_STRING_TYPENAME
range_result_iterator<CollectionT>::type input_iterator_type; range_result_iterator<RangeT>::type input_iterator_type;
typedef split_iterator<input_iterator_type> find_iterator_type; typedef split_iterator<input_iterator_type> find_iterator_type;
typedef detail::copy_iterator_rangeF< typedef detail::copy_iterator_rangeF<
BOOST_STRING_TYPENAME BOOST_STRING_TYPENAME

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

@ -38,7 +38,7 @@ namespace boost {
//! 'Starts with' predicate //! 'Starts with' predicate
/*! /*!
This predicate holds when the test collection is a prefix of the Input. This predicate holds when the test string is a prefix of the Input.
In other words, if the input starts with the test. In other words, if the input starts with the test.
When the optional predicate is specified, it is used for character-wise When the optional predicate is specified, it is used for character-wise
comparison. comparison.
@ -50,16 +50,16 @@ namespace boost {
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template<typename Collection1T, typename Collection2T, typename PredicateT> template<typename Range1T, typename Range2T, typename PredicateT>
inline bool starts_with( inline bool starts_with(
const Collection1T& Input, const Range1T& Input,
const Collection2T& Test, const Range2T& Test,
PredicateT Comp) PredicateT Comp)
{ {
typedef BOOST_STRING_TYPENAME typedef BOOST_STRING_TYPENAME
range_const_iterator<Collection1T>::type Iterator1T; range_const_iterator<Range1T>::type Iterator1T;
typedef BOOST_STRING_TYPENAME typedef BOOST_STRING_TYPENAME
range_const_iterator<Collection2T>::type Iterator2T; range_const_iterator<Range2T>::type Iterator2T;
Iterator1T InputEnd=end(Input); Iterator1T InputEnd=end(Input);
Iterator2T TestEnd=end(Test); Iterator2T TestEnd=end(Test);
@ -81,17 +81,17 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename Collection1T, typename Collection2T> template<typename Range1T, typename Range2T>
inline bool starts_with( inline bool starts_with(
const Collection1T& Input, const Range1T& Input,
const Collection2T& Test) const Range2T& Test)
{ {
return starts_with(Input, Test, is_equal()); return starts_with(Input, Test, is_equal());
} }
//! 'Starts with' predicate ( case insensitive ) //! 'Starts with' predicate ( case insensitive )
/*! /*!
This predicate holds when the test container is a prefix of the Input. This predicate holds when the test string is a prefix of the Input.
In other words, if the input starts with the test. In other words, if the input starts with the test.
Elements are compared case insensitively. Elements are compared case insensitively.
@ -102,10 +102,10 @@ namespace boost {
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template<typename Collection1T, typename Collection2T> template<typename Range1T, typename Range2T>
inline bool istarts_with( inline bool istarts_with(
const Collection1T& Input, const Range1T& Input,
const Collection2T& Test, const Range2T& Test,
const std::locale& Loc=std::locale()) const std::locale& Loc=std::locale())
{ {
return starts_with(Input, Test, is_iequal(Loc)); return starts_with(Input, Test, is_iequal(Loc));
@ -116,7 +116,7 @@ namespace boost {
//! 'Ends with' predicate //! 'Ends with' predicate
/*! /*!
This predicate holds when the test container is a suffix of the Input. This predicate holds when the test string is a suffix of the Input.
In other words, if the input ends with the test. In other words, if the input ends with the test.
When the optional predicate is specified, it is used for character-wise When the optional predicate is specified, it is used for character-wise
comparison. comparison.
@ -129,14 +129,14 @@ namespace boost {
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template<typename Collection1T, typename Collection2T, typename PredicateT> template<typename Range1T, typename Range2T, typename PredicateT>
inline bool ends_with( inline bool ends_with(
const Collection1T& Input, const Range1T& Input,
const Collection2T& Test, const Range2T& Test,
PredicateT Comp) PredicateT Comp)
{ {
typedef BOOST_STRING_TYPENAME typedef BOOST_STRING_TYPENAME
range_const_iterator<Collection1T>::type Iterator1T; range_const_iterator<Range1T>::type Iterator1T;
typedef BOOST_STRING_TYPENAME boost::detail:: typedef BOOST_STRING_TYPENAME boost::detail::
iterator_traits<Iterator1T>::iterator_category category; iterator_traits<Iterator1T>::iterator_category category;
@ -155,10 +155,10 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename Collection1T, typename Collection2T> template<typename Range1T, typename Range2T>
inline bool ends_with( inline bool ends_with(
const Collection1T& Input, const Range1T& Input,
const Collection2T& Test) const Range2T& Test)
{ {
return ends_with(Input, Test, is_equal()); return ends_with(Input, Test, is_equal());
} }
@ -176,10 +176,10 @@ namespace boost {
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template<typename Collection1T, typename Collection2T> template<typename Range1T, typename Range2T>
inline bool iends_with( inline bool iends_with(
const Collection1T& Input, const Range1T& Input,
const Collection2T& Test, const Range2T& Test,
const std::locale& Loc=std::locale()) const std::locale& Loc=std::locale())
{ {
return ends_with(Input, Test, is_iequal(Loc)); return ends_with(Input, Test, is_iequal(Loc));
@ -200,10 +200,10 @@ namespace boost {
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template<typename Collection1T, typename Collection2T, typename PredicateT> template<typename Range1T, typename Range2T, typename PredicateT>
inline bool contains( inline bool contains(
const Collection1T& Input, const Range1T& Input,
const Collection2T& Test, const Range2T& Test,
PredicateT Comp) PredicateT Comp)
{ {
if (empty(Test)) if (empty(Test))
@ -221,10 +221,10 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename Collection1T, typename Collection2T> template<typename Range1T, typename Range2T>
inline bool contains( inline bool contains(
const Collection1T& Input, const Range1T& Input,
const Collection2T& Test) const Range2T& Test)
{ {
return contains(Input, Test, is_equal()); return contains(Input, Test, is_equal());
} }
@ -241,10 +241,10 @@ namespace boost {
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template<typename Collection1T, typename Collection2T> template<typename Range1T, typename Range2T>
inline bool icontains( inline bool icontains(
const Collection1T& Input, const Range1T& Input,
const Collection2T& Test, const Range2T& Test,
const std::locale& Loc=std::locale()) const std::locale& Loc=std::locale())
{ {
return contains(Input, Test, is_iequal(Loc)); return contains(Input, Test, is_iequal(Loc));
@ -268,16 +268,16 @@ namespace boost {
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template<typename Collection1T, typename Collection2T, typename PredicateT> template<typename Range1T, typename Range2T, typename PredicateT>
inline bool equals( inline bool equals(
const Collection1T& Input, const Range1T& Input,
const Collection2T& Test, const Range2T& Test,
PredicateT Comp) PredicateT Comp)
{ {
typedef BOOST_STRING_TYPENAME typedef BOOST_STRING_TYPENAME
range_const_iterator<Collection1T>::type Iterator1T; range_const_iterator<Range1T>::type Iterator1T;
typedef BOOST_STRING_TYPENAME typedef BOOST_STRING_TYPENAME
range_const_iterator<Collection2T>::type Iterator2T; range_const_iterator<Range2T>::type Iterator2T;
Iterator1T InputEnd=end(Input); Iterator1T InputEnd=end(Input);
Iterator2T TestEnd=end(Test); Iterator2T TestEnd=end(Test);
@ -299,10 +299,10 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename Collection1T, typename Collection2T> template<typename Range1T, typename Range2T>
inline bool equals( inline bool equals(
const Collection1T& Input, const Range1T& Input,
const Collection2T& Test) const Range2T& Test)
{ {
return equals(Input, Test, is_equal()); return equals(Input, Test, is_equal());
} }
@ -322,10 +322,10 @@ namespace boost {
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template<typename Collection1T, typename Collection2T> template<typename Range1T, typename Range2T>
inline bool iequals( inline bool iequals(
const Collection1T& Input, const Range1T& Input,
const Collection2T& Test, const Range2T& Test,
const std::locale& Loc=std::locale()) const std::locale& Loc=std::locale())
{ {
return equals(Input, Test, is_iequal(Loc)); return equals(Input, Test, is_iequal(Loc));
@ -344,13 +344,13 @@ namespace boost {
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template<typename CollectionT, typename PredicateT> template<typename RangeT, typename PredicateT>
inline bool all( inline bool all(
const CollectionT& Input, const RangeT& Input,
PredicateT Pred) PredicateT Pred)
{ {
typedef BOOST_STRING_TYPENAME typedef BOOST_STRING_TYPENAME
range_const_iterator<CollectionT>::type Iterator1T; range_const_iterator<RangeT>::type Iterator1T;
Iterator1T InputEnd=end(Input); Iterator1T InputEnd=end(Input);
for( Iterator1T It=begin(Input); It!=InputEnd; ++It) for( Iterator1T It=begin(Input); It!=InputEnd; ++It)

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

@ -41,20 +41,20 @@ namespace boost {
\param Flags Regex options \param Flags Regex options
\return \return
An \c iterator_range delimiting the match. An \c iterator_range delimiting the match.
Returned iterator is either \c InputContainerT::iterator or Returned iterator is either \c RangeT::iterator or
\c InputContainerT::const_iterator, depending on the constness of \c RangeT::const_iterator, depending on the constness of
the input parameter. the input parameter.
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template< template<
typename CollectionT, typename RangeT,
typename CharT, typename CharT,
typename RegexTraitsT> typename RegexTraitsT>
inline iterator_range< inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type > BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type >
find_regex( find_regex(
CollectionT& Input, RangeT& Input,
const basic_regex<CharT, RegexTraitsT>& Rx, const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default ) match_flag_type Flags=match_default )
{ {
@ -83,13 +83,13 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename CollectionT, typename RangeT,
typename CharT, typename CharT,
typename RegexTraitsT, typename RegexTraitsT,
typename FormatStringTraitsT, typename FormatStringAllocatorT > typename FormatStringTraitsT, typename FormatStringAllocatorT >
inline OutputIteratorT replace_regex_copy( inline OutputIteratorT replace_regex_copy(
OutputIteratorT Output, OutputIteratorT Output,
const CollectionT& Input, const RangeT& Input,
const basic_regex<CharT, RegexTraitsT>& Rx, const basic_regex<CharT, RegexTraitsT>& Rx,
const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
match_flag_type Flags=match_default | format_default ) match_flag_type Flags=match_default | format_default )
@ -169,13 +169,13 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename CollectionT, typename RangeT,
typename CharT, typename CharT,
typename RegexTraitsT, typename RegexTraitsT,
typename FormatStringTraitsT, typename FormatStringAllocatorT > typename FormatStringTraitsT, typename FormatStringAllocatorT >
inline OutputIteratorT replace_all_regex_copy( inline OutputIteratorT replace_all_regex_copy(
OutputIteratorT Output, OutputIteratorT Output,
const CollectionT& Input, const RangeT& Input,
const basic_regex<CharT, RegexTraitsT>& Rx, const basic_regex<CharT, RegexTraitsT>& Rx,
const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
match_flag_type Flags=match_default | format_default ) match_flag_type Flags=match_default | format_default )
@ -254,12 +254,12 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename CollectionT, typename RangeT,
typename CharT, typename CharT,
typename RegexTraitsT > typename RegexTraitsT >
inline OutputIteratorT erase_regex_copy( inline OutputIteratorT erase_regex_copy(
OutputIteratorT Output, OutputIteratorT Output,
const CollectionT& Input, const RangeT& Input,
const basic_regex<CharT, RegexTraitsT>& Rx, const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default ) match_flag_type Flags=match_default )
{ {
@ -333,12 +333,12 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename CollectionT, typename RangeT,
typename CharT, typename CharT,
typename RegexTraitsT > typename RegexTraitsT >
inline OutputIteratorT erase_all_regex_copy( inline OutputIteratorT erase_all_regex_copy(
OutputIteratorT Output, OutputIteratorT Output,
const CollectionT& Input, const RangeT& Input,
const basic_regex<CharT, RegexTraitsT>& Rx, const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default ) match_flag_type Flags=match_default )
{ {
@ -418,12 +418,12 @@ namespace boost {
*/ */
template< template<
typename SequenceSequenceT, typename SequenceSequenceT,
typename CollectionT, typename RangeT,
typename CharT, typename CharT,
typename RegexTraitsT > typename RegexTraitsT >
inline SequenceSequenceT& find_all_regex( inline SequenceSequenceT& find_all_regex(
SequenceSequenceT& Result, SequenceSequenceT& Result,
const CollectionT& Input, const RangeT& Input,
const basic_regex<CharT, RegexTraitsT>& Rx, const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default ) match_flag_type Flags=match_default )
{ {
@ -459,12 +459,12 @@ namespace boost {
*/ */
template< template<
typename SequenceSequenceT, typename SequenceSequenceT,
typename CollectionT, typename RangeT,
typename CharT, typename CharT,
typename RegexTraitsT > typename RegexTraitsT >
inline SequenceSequenceT& split_regex( inline SequenceSequenceT& split_regex(
SequenceSequenceT& Result, SequenceSequenceT& Result,
const CollectionT& Input, const RangeT& Input,
const basic_regex<CharT, RegexTraitsT>& Rx, const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default ) match_flag_type Flags=match_default )
{ {

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

@ -50,15 +50,15 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T> typename Range2T>
inline OutputIteratorT replace_range_copy( inline OutputIteratorT replace_range_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
const iterator_range< const iterator_range<
BOOST_STRING_TYPENAME BOOST_STRING_TYPENAME
range_const_iterator<Collection1T>::type>& SearchRange, range_const_iterator<Range1T>::type>& SearchRange,
const Collection2T& Format) const Range2T& Format)
{ {
return find_format_copy( return find_format_copy(
Output, Output,
@ -71,13 +71,13 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline SequenceT replace_range_copy( inline SequenceT replace_range_copy(
const SequenceT& Input, const SequenceT& Input,
const iterator_range< const iterator_range<
BOOST_STRING_TYPENAME BOOST_STRING_TYPENAME
range_const_iterator<SequenceT>::type>& SearchRange, range_const_iterator<SequenceT>::type>& SearchRange,
const CollectionT& Format) const RangeT& Format)
{ {
return find_format_copy( return find_format_copy(
Input, Input,
@ -94,13 +94,13 @@ namespace boost {
\param SearchRange A range in the input to be substituted \param SearchRange A range in the input to be substituted
\param Format A substitute string \param Format A substitute string
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline void replace_range( inline void replace_range(
SequenceT& Input, SequenceT& Input,
const iterator_range< const iterator_range<
BOOST_STRING_TYPENAME BOOST_STRING_TYPENAME
range_iterator<SequenceT>::type>& SearchRange, range_iterator<SequenceT>::type>& SearchRange,
const CollectionT& Format) const RangeT& Format)
{ {
find_format( find_format(
Input, Input,
@ -128,14 +128,14 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T, typename Range2T,
typename Collection3T> typename Range3T>
inline OutputIteratorT replace_first_copy( inline OutputIteratorT replace_first_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
const Collection2T& Search, const Range2T& Search,
const Collection3T& Format) const Range3T& Format)
{ {
return find_format_copy( return find_format_copy(
Output, Output,
@ -148,11 +148,11 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Range1T, typename Range2T>
inline SequenceT replace_first_copy( inline SequenceT replace_first_copy(
const SequenceT& Input, const SequenceT& Input,
const Collection1T& Search, const Range1T& Search,
const Collection2T& Format ) const Range2T& Format )
{ {
return find_format_copy( return find_format_copy(
Input, Input,
@ -169,11 +169,11 @@ namespace boost {
\param Search A substring to be searched for \param Search A substring to be searched for
\param Format A substitute string \param Format A substitute string
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Range1T, typename Range2T>
inline void replace_first( inline void replace_first(
SequenceT& Input, SequenceT& Input,
const Collection1T& Search, const Range1T& Search,
const Collection2T& Format ) const Range2T& Format )
{ {
find_format( find_format(
Input, Input,
@ -203,14 +203,14 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T, typename Range2T,
typename Collection3T> typename Range3T>
inline OutputIteratorT ireplace_first_copy( inline OutputIteratorT ireplace_first_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
const Collection2T& Search, const Range2T& Search,
const Collection3T& Format, const Range3T& Format,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
return find_format_copy( return find_format_copy(
@ -224,11 +224,11 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename Collection2T, typename Collection1T> template<typename SequenceT, typename Range2T, typename Range1T>
inline SequenceT ireplace_first_copy( inline SequenceT ireplace_first_copy(
const SequenceT& Input, const SequenceT& Input,
const Collection2T& Search, const Range2T& Search,
const Collection1T& Format, const Range1T& Format,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
return find_format_copy( return find_format_copy(
@ -248,11 +248,11 @@ namespace boost {
\param Format A substitute string \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 Range1T, typename Range2T>
inline void ireplace_first( inline void ireplace_first(
SequenceT& Input, SequenceT& Input,
const Collection1T& Search, const Range1T& Search,
const Collection2T& Format, const Range2T& Format,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
find_format( find_format(
@ -281,14 +281,14 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T, typename Range2T,
typename Collection3T> typename Range3T>
inline OutputIteratorT replace_last_copy( inline OutputIteratorT replace_last_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
const Collection2T& Search, const Range2T& Search,
const Collection3T& Format ) const Range3T& Format )
{ {
return find_format_copy( return find_format_copy(
Output, Output,
@ -301,11 +301,11 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Range1T, typename Range2T>
inline SequenceT replace_last_copy( inline SequenceT replace_last_copy(
const SequenceT& Input, const SequenceT& Input,
const Collection1T& Search, const Range1T& Search,
const Collection2T& Format ) const Range2T& Format )
{ {
return find_format_copy( return find_format_copy(
Input, Input,
@ -322,11 +322,11 @@ namespace boost {
\param Search A substring to be searched for \param Search A substring to be searched for
\param Format A substitute string \param Format A substitute string
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Range1T, typename Range2T>
inline void replace_last( inline void replace_last(
SequenceT& Input, SequenceT& Input,
const Collection1T& Search, const Range1T& Search,
const Collection2T& Format ) const Range2T& Format )
{ {
find_format( find_format(
Input, Input,
@ -356,14 +356,14 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T, typename Range2T,
typename Collection3T> typename Range3T>
inline OutputIteratorT ireplace_last_copy( inline OutputIteratorT ireplace_last_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
const Collection2T& Search, const Range2T& Search,
const Collection3T& Format, const Range3T& Format,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
return find_format_copy( return find_format_copy(
@ -377,11 +377,11 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Range1T, typename Range2T>
inline SequenceT ireplace_last_copy( inline SequenceT ireplace_last_copy(
const SequenceT& Input, const SequenceT& Input,
const Collection1T& Search, const Range1T& Search,
const Collection2T& Format, const Range2T& Format,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
return find_format_copy( return find_format_copy(
@ -402,11 +402,11 @@ namespace boost {
\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
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Range1T, typename Range2T>
inline void ireplace_last( inline void ireplace_last(
SequenceT& Input, SequenceT& Input,
const Collection1T& Search, const Range1T& Search,
const Collection2T& Format, const Range2T& Format,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
find_format( find_format(
@ -436,15 +436,15 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T, typename Range2T,
typename Collection3T> typename Range3T>
inline OutputIteratorT replace_nth_copy( inline OutputIteratorT replace_nth_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
const Collection2T& Search, const Range2T& Search,
unsigned int Nth, unsigned int Nth,
const Collection3T& Format ) const Range3T& Format )
{ {
return find_format_copy( return find_format_copy(
Output, Output,
@ -457,12 +457,12 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Range1T, typename Range2T>
inline SequenceT replace_nth_copy( inline SequenceT replace_nth_copy(
const SequenceT& Input, const SequenceT& Input,
const Collection1T& Search, const Range1T& Search,
unsigned int Nth, unsigned int Nth,
const Collection2T& Format ) const Range2T& Format )
{ {
return find_format_copy( return find_format_copy(
Input, Input,
@ -480,12 +480,12 @@ namespace boost {
\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 string \param Format A substitute string
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Range1T, typename Range2T>
inline void replace_nth( inline void replace_nth(
SequenceT& Input, SequenceT& Input,
const Collection1T& Search, const Range1T& Search,
unsigned int Nth, unsigned int Nth,
const Collection2T& Format ) const Range2T& Format )
{ {
find_format( find_format(
Input, Input,
@ -516,15 +516,15 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T, typename Range2T,
typename Collection3T> typename Range3T>
inline OutputIteratorT ireplace_nth_copy( inline OutputIteratorT ireplace_nth_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
const Collection2T& Search, const Range2T& Search,
unsigned int Nth, unsigned int Nth,
const Collection3T& Format, const Range3T& Format,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
return find_format_copy( return find_format_copy(
@ -538,12 +538,12 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Range1T, typename Range2T>
inline SequenceT ireplace_nth_copy( inline SequenceT ireplace_nth_copy(
const SequenceT& Input, const SequenceT& Input,
const Collection1T& Search, const Range1T& Search,
unsigned int Nth, unsigned int Nth,
const Collection2T& Format, const Range2T& Format,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
return find_format_copy( return find_format_copy(
@ -564,12 +564,12 @@ namespace boost {
\param Format A substitute string \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 Range1T, typename Range2T>
inline void ireplace_nth( inline void ireplace_nth(
SequenceT& Input, SequenceT& Input,
const Collection1T& Search, const Range1T& Search,
unsigned int Nth, unsigned int Nth,
const Collection2T& Format, const Range2T& Format,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
find_format( find_format(
@ -598,14 +598,14 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T, typename Range2T,
typename Collection3T> typename Range3T>
inline OutputIteratorT replace_all_copy( inline OutputIteratorT replace_all_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
const Collection2T& Search, const Range2T& Search,
const Collection3T& Format ) const Range3T& Format )
{ {
return find_format_all_copy( return find_format_all_copy(
Output, Output,
@ -618,11 +618,11 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Range1T, typename Range2T>
inline SequenceT replace_all_copy( inline SequenceT replace_all_copy(
const SequenceT& Input, const SequenceT& Input,
const Collection1T& Search, const Range1T& Search,
const Collection2T& Format ) const Range2T& Format )
{ {
return find_format_all_copy( return find_format_all_copy(
Input, Input,
@ -640,11 +640,11 @@ namespace boost {
\param Format A substitute string \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 Range1T, typename Range2T>
inline void replace_all( inline void replace_all(
SequenceT& Input, SequenceT& Input,
const Collection1T& Search, const Range1T& Search,
const Collection2T& Format ) const Range2T& Format )
{ {
find_format_all( find_format_all(
Input, Input,
@ -674,14 +674,14 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T, typename Range2T,
typename Collection3T> typename Range3T>
inline OutputIteratorT ireplace_all_copy( inline OutputIteratorT ireplace_all_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
const Collection2T& Search, const Range2T& Search,
const Collection3T& Format, const Range3T& Format,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
return find_format_all_copy( return find_format_all_copy(
@ -695,11 +695,11 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename Collection1T, typename Collection2T> template<typename SequenceT, typename Range1T, typename Range2T>
inline SequenceT ireplace_all_copy( inline SequenceT ireplace_all_copy(
const SequenceT& Input, const SequenceT& Input,
const Collection1T& Search, const Range1T& Search,
const Collection2T& Format, const Range2T& Format,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
return find_format_all_copy( return find_format_all_copy(
@ -719,11 +719,11 @@ namespace boost {
\param Format A substitute string \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 Range1T, typename Range2T>
inline void ireplace_all( inline void ireplace_all(
SequenceT& Input, SequenceT& Input,
const Collection1T& Search, const Range1T& Search,
const Collection2T& Format, const Range2T& Format,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
find_format_all( find_format_all(
@ -754,13 +754,13 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T> typename Range2T>
inline OutputIteratorT replace_head_copy( inline OutputIteratorT replace_head_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
unsigned int N, unsigned int N,
const Collection2T& Format ) const Range2T& Format )
{ {
return find_format_copy( return find_format_copy(
Output, Output,
@ -773,11 +773,11 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline SequenceT replace_head_copy( inline SequenceT replace_head_copy(
const SequenceT& Input, const SequenceT& Input,
unsigned int N, unsigned int N,
const CollectionT& Format ) const RangeT& Format )
{ {
return find_format_copy( return find_format_copy(
Input, Input,
@ -796,11 +796,11 @@ namespace boost {
\param N Length of the head \param N Length of the head
\param Format A substitute string \param Format A substitute string
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline void replace_head( inline void replace_head(
SequenceT& Input, SequenceT& Input,
unsigned int N, unsigned int N,
const CollectionT& Format ) const RangeT& Format )
{ {
find_format( find_format(
Input, Input,
@ -830,13 +830,13 @@ namespace boost {
*/ */
template< template<
typename OutputIteratorT, typename OutputIteratorT,
typename Collection1T, typename Range1T,
typename Collection2T> typename Range2T>
inline OutputIteratorT replace_tail_copy( inline OutputIteratorT replace_tail_copy(
OutputIteratorT Output, OutputIteratorT Output,
const Collection1T& Input, const Range1T& Input,
unsigned int N, unsigned int N,
const Collection2T& Format ) const Range2T& Format )
{ {
return find_format_copy( return find_format_copy(
Output, Output,
@ -849,11 +849,11 @@ namespace boost {
/*! /*!
\overload \overload
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline SequenceT replace_tail_copy( inline SequenceT replace_tail_copy(
const SequenceT& Input, const SequenceT& Input,
unsigned int N, unsigned int N,
const CollectionT& Format ) const RangeT& Format )
{ {
return find_format_copy( return find_format_copy(
Input, Input,
@ -872,11 +872,11 @@ namespace boost {
\param N Length of the tail \param N Length of the tail
\param Format A substitute string \param Format A substitute string
*/ */
template<typename SequenceT, typename CollectionT> template<typename SequenceT, typename RangeT>
inline void replace_tail( inline void replace_tail(
SequenceT& Input, SequenceT& Input,
unsigned int N, unsigned int N,
const CollectionT& Format ) const RangeT& Format )
{ {
find_format( find_format(
Input, Input,

16
include/boost/algorithm/string/split.hpp
View File

@ -57,11 +57,11 @@ namespace boost {
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template< typename SequenceSequenceT, typename Collection1T, typename Collection2T > template< typename SequenceSequenceT, typename Range1T, typename Range2T >
inline SequenceSequenceT& find_all( inline SequenceSequenceT& find_all(
SequenceSequenceT& Result, SequenceSequenceT& Result,
Collection1T& Input, Range1T& Input,
const Collection2T& Search) const Range2T& Search)
{ {
return iter_find( return iter_find(
Result, Result,
@ -92,11 +92,11 @@ namespace boost {
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template< typename SequenceSequenceT, typename Collection1T, typename Collection2T > template< typename SequenceSequenceT, typename Range1T, typename Range2T >
inline SequenceSequenceT& ifind_all( inline SequenceSequenceT& ifind_all(
SequenceSequenceT& Result, SequenceSequenceT& Result,
Collection1T& Input, Range1T& Input,
const Collection2T& Search, const Range2T& Search,
const std::locale& Loc=std::locale() ) const std::locale& Loc=std::locale() )
{ {
return iter_find( return iter_find(
@ -135,10 +135,10 @@ namespace boost {
\note This function provides the strong exception-safety guarantee \note This function provides the strong exception-safety guarantee
*/ */
template< typename SequenceSequenceT, typename CollectionT, typename PredicateT > template< typename SequenceSequenceT, typename RangeT, typename PredicateT >
inline SequenceSequenceT& split( inline SequenceSequenceT& split(
SequenceSequenceT& Result, SequenceSequenceT& Result,
CollectionT& Input, RangeT& Input,
PredicateT Pred, PredicateT Pred,
token_compress_mode_type eCompress=token_compress_off ) token_compress_mode_type eCompress=token_compress_off )
{ {

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

@ -54,10 +54,10 @@ namespace boost {
\note The second variant of this function provides the strong exception-safety guarantee \note The second variant of this function provides the strong exception-safety guarantee
*/ */
template<typename OutputIteratorT, typename CollectionT, typename PredicateT> template<typename OutputIteratorT, typename RangeT, typename PredicateT>
inline OutputIteratorT trim_left_copy_if( inline OutputIteratorT trim_left_copy_if(
OutputIteratorT Output, OutputIteratorT Output,
const CollectionT& Input, const RangeT& Input,
PredicateT IsSpace) PredicateT IsSpace)
{ {
std::copy( std::copy(
@ -160,10 +160,10 @@ namespace boost {
\note The second variant of this function provides the strong exception-safety guarantee \note The second variant of this function provides the strong exception-safety guarantee
*/ */
template<typename OutputIteratorT, typename CollectionT, typename PredicateT> template<typename OutputIteratorT, typename RangeT, typename PredicateT>
inline OutputIteratorT trim_right_copy_if( inline OutputIteratorT trim_right_copy_if(
OutputIteratorT Output, OutputIteratorT Output,
const CollectionT& Input, const RangeT& Input,
PredicateT IsSpace ) PredicateT IsSpace )
{ {
std::copy( std::copy(
@ -270,14 +270,14 @@ namespace boost {
\note The second variant of this function provides the strong exception-safety guarantee \note The second variant of this function provides the strong exception-safety guarantee
*/ */
template<typename OutputIteratorT, typename CollectionT, typename PredicateT> template<typename OutputIteratorT, typename RangeT, typename PredicateT>
inline OutputIteratorT trim_copy_if( inline OutputIteratorT trim_copy_if(
OutputIteratorT Output, OutputIteratorT Output,
const CollectionT& Input, const RangeT& Input,
PredicateT IsSpace) PredicateT IsSpace)
{ {
BOOST_STRING_TYPENAME BOOST_STRING_TYPENAME
range_const_iterator<CollectionT>::type TrimEnd= range_const_iterator<RangeT>::type TrimEnd=
detail::trim_end( detail::trim_end(
begin(Input), begin(Input),
end(Input), end(Input),