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.
\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
\return
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
*/
template<typename OutputIteratorT, typename CollectionT>
template<typename OutputIteratorT, typename RangeT>
inline OutputIteratorT
to_lower_copy(
OutputIteratorT Output,
const CollectionT& Input,
const RangeT& Input,
const std::locale& Loc=std::locale())
{
return std::transform(
@ -60,7 +60,7 @@ namespace boost {
end(Input),
Output,
detail::to_lowerF<
typename range_value<CollectionT>::type >(Loc));
typename range_value<RangeT>::type >(Loc));
}
//! Convert to lower case
@ -88,12 +88,12 @@ namespace boost {
Each element of the input sequence is converted to lower
case. The input sequence is modified in-place.
\param Input A collection
\param Input A range
\param Loc a locale used for conversion
*/
template<typename MutableCollectionT>
template<typename WritableRangeT>
inline void to_lower(
MutableCollectionT& Input,
WritableRangeT& Input,
const std::locale& Loc=std::locale())
{
std::transform(
@ -101,7 +101,7 @@ namespace boost {
end(Input),
begin(Input),
detail::to_lowerF<
typename range_value<MutableCollectionT>::type >(Loc));
typename range_value<WritableRangeT>::type >(Loc));
}
// to_upper -----------------------------------------------//
@ -113,7 +113,7 @@ namespace boost {
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 Input An input collection
\param Input An input range
\param Loc A locale used for conversion
\return
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
*/
template<typename OutputIteratorT, typename CollectionT>
template<typename OutputIteratorT, typename RangeT>
inline OutputIteratorT
to_upper_copy(
OutputIteratorT Output,
const CollectionT& Input,
const RangeT& Input,
const std::locale& Loc=std::locale())
{
return std::transform(
@ -133,7 +133,7 @@ namespace boost {
end(Input),
Output,
detail::to_upperF<
typename range_value<CollectionT>::type >(Loc));
typename range_value<RangeT>::type >(Loc));
}
//! Convert to upper case
@ -162,12 +162,12 @@ namespace boost {
Each element of the input sequence is converted to upper
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
*/
template<typename MutableCollectionT>
template<typename WritableRangeT>
inline void to_upper(
MutableCollectionT& Input,
WritableRangeT& Input,
const std::locale& Loc=std::locale())
{
std::transform(
@ -175,7 +175,7 @@ namespace boost {
end(Input),
begin(Input),
detail::to_upperF<
typename range_value<MutableCollectionT>::type >(Loc));
typename range_value<WritableRangeT>::type >(Loc));
}
} // 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
\return An instance of the \c is_any_of predicate
*/
template<typename ContainerT>
template<typename RangeT>
inline detail::is_any_ofF<
BOOST_STRING_TYPENAME range_value<ContainerT>::type>
is_any_of( const ContainerT& Set )
BOOST_STRING_TYPENAME range_value<RangeT>::type>
is_any_of( const RangeT& Set )
{
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

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

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

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

@ -27,22 +27,22 @@ namespace boost {
// const format functor ----------------------------------------------------//
// constant format functor
template<typename CollectionT>
template<typename RangeT>
struct const_formatF
{
private:
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;
public:
// Construction
const_formatF(const CollectionT& Format) :
const_formatF(const RangeT& Format) :
m_Format(begin(Format), end(Format)) {}
// Operation
template<typename Collection2T>
const result_type& operator()(const Collection2T&) const
template<typename Range2T>
const result_type& operator()(const Range2T&) const
{
return m_Format;
}
@ -54,14 +54,14 @@ namespace boost {
// identity format functor ----------------------------------------------------//
// identity format functor
template<typename CollectionT>
template<typename RangeT>
struct identity_formatF
{
// Operation
template< typename Collection2T >
const CollectionT& operator()(const Collection2T& Replace) const
template< typename Range2T >
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
*/
template<typename OutputIteratorT, typename CollectionT>
template<typename OutputIteratorT, typename RangeT>
inline OutputIteratorT erase_range_copy(
OutputIteratorT Output,
const CollectionT& Input,
const RangeT& Input,
const iterator_range<
BOOST_STRING_TYPENAME
range_const_iterator<CollectionT>::type>& SearchRange )
range_const_iterator<RangeT>::type>& SearchRange )
{
return find_format_copy(
Output,
@ -116,12 +116,12 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T>
typename Range1T,
typename Range2T>
inline OutputIteratorT erase_first_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Collection2T& Search )
const Range1T& Input,
const Range2T& Search )
{
return find_format_copy(
Output,
@ -134,10 +134,10 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline SequenceT erase_first_copy(
const SequenceT& Input,
const CollectionT& Search )
const RangeT& Search )
{
return find_format_copy(
Input,
@ -153,10 +153,10 @@ namespace boost {
\param Input An input string
\param Search A substring to be searched for.
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline void erase_first(
SequenceT& Input,
const CollectionT& Search )
const RangeT& Search )
{
find_format(
Input,
@ -184,12 +184,12 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T>
typename Range1T,
typename Range2T>
inline OutputIteratorT ierase_first_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Collection2T& Search,
const Range1T& Input,
const Range2T& Search,
const std::locale& Loc=std::locale() )
{
return find_format_copy(
@ -203,10 +203,10 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline SequenceT ierase_first_copy(
const SequenceT& Input,
const CollectionT& Search,
const RangeT& Search,
const std::locale& Loc=std::locale() )
{
return find_format_copy(
@ -224,10 +224,10 @@ namespace boost {
\param Search A substring to be searched for
\param Loc A locale used for case insensitive comparison
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline void ierase_first(
SequenceT& Input,
const CollectionT& Search,
const RangeT& Search,
const std::locale& Loc=std::locale() )
{
find_format(
@ -254,12 +254,12 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T>
typename Range1T,
typename Range2T>
inline OutputIteratorT erase_last_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Collection2T& Search )
const Range1T& Input,
const Range2T& Search )
{
return find_format_copy(
Output,
@ -272,10 +272,10 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline SequenceT erase_last_copy(
const SequenceT& Input,
const CollectionT& Search )
const RangeT& Search )
{
return find_format_copy(
Input,
@ -291,10 +291,10 @@ namespace boost {
\param Input An input string
\param Search A substring to be searched for
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline void erase_last(
SequenceT& Input,
const CollectionT& Search )
const RangeT& Search )
{
find_format(
Input,
@ -322,12 +322,12 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T>
typename Range1T,
typename Range2T>
inline OutputIteratorT ierase_last_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Collection2T& Search,
const Range1T& Input,
const Range2T& Search,
const std::locale& Loc=std::locale() )
{
return find_format_copy(
@ -341,10 +341,10 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline SequenceT ierase_last_copy(
const SequenceT& Input,
const CollectionT& Search,
const RangeT& Search,
const std::locale& Loc=std::locale() )
{
return find_format_copy(
@ -362,10 +362,10 @@ namespace boost {
\param Search A substring to be searched for
\param Loc A locale used for case insensitive comparison
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline void ierase_last(
SequenceT& Input,
const CollectionT& Search,
const RangeT& Search,
const std::locale& Loc=std::locale() )
{
find_format(
@ -394,12 +394,12 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T>
typename Range1T,
typename Range2T>
inline OutputIteratorT erase_nth_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Collection2T& Search,
const Range1T& Input,
const Range2T& Search,
unsigned int Nth )
{
return find_format_copy(
@ -413,10 +413,10 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline SequenceT erase_nth_copy(
const SequenceT& Input,
const CollectionT& Search,
const RangeT& Search,
unsigned int Nth )
{
return find_format_copy(
@ -434,10 +434,10 @@ namespace boost {
\param Search A substring to be searched for.
\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(
SequenceT& Input,
const CollectionT& Search,
const RangeT& Search,
unsigned int Nth )
{
find_format(
@ -467,12 +467,12 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T>
typename Range1T,
typename Range2T>
inline OutputIteratorT ierase_nth_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Collection2T& Search,
const Range1T& Input,
const Range2T& Search,
unsigned int Nth,
const std::locale& Loc=std::locale() )
{
@ -487,10 +487,10 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline SequenceT ierase_nth_copy(
const SequenceT& Input,
const CollectionT& Search,
const RangeT& Search,
unsigned int Nth,
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 Loc A locale used for case insensitive comparison
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline void ierase_nth(
SequenceT& Input,
const CollectionT& Search,
const RangeT& Search,
unsigned int Nth,
const std::locale& Loc=std::locale() )
{
@ -543,12 +543,12 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T>
typename Range1T,
typename Range2T>
inline OutputIteratorT erase_all_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Collection2T& Search )
const Range1T& Input,
const Range2T& Search )
{
return find_format_all_copy(
Output,
@ -561,10 +561,10 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline SequenceT erase_all_copy(
const SequenceT& Input,
const CollectionT& Search )
const RangeT& Search )
{
return find_format_all_copy(
Input,
@ -580,10 +580,10 @@ namespace boost {
\param Input An input string
\param Search A substring to be searched for.
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline void erase_all(
SequenceT& Input,
const CollectionT& Search )
const RangeT& Search )
{
find_format_all(
Input,
@ -611,12 +611,12 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T>
typename Range1T,
typename Range2T>
inline OutputIteratorT ierase_all_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Collection2T& Search,
const Range1T& Input,
const Range2T& Search,
const std::locale& Loc=std::locale() )
{
return find_format_all_copy(
@ -630,10 +630,10 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline SequenceT ierase_all_copy(
const SequenceT& Input,
const CollectionT& Search,
const RangeT& Search,
const std::locale& Loc=std::locale() )
{
return find_format_all_copy(
@ -651,10 +651,10 @@ namespace boost {
\param Search A substring to be searched for.
\param Loc A locale used for case insensitive comparison
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline void ierase_all(
SequenceT& Input,
const CollectionT& Search,
const RangeT& Search,
const std::locale& Loc=std::locale() )
{
find_format_all(
@ -683,10 +683,10 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename CollectionT>
typename RangeT>
inline OutputIteratorT erase_head_copy(
OutputIteratorT Output,
const CollectionT& Input,
const RangeT& Input,
unsigned int N )
{
return find_format_copy(
@ -751,10 +751,10 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename CollectionT>
typename RangeT>
inline OutputIteratorT erase_tail_copy(
OutputIteratorT Output,
const CollectionT& Input,
const RangeT& Input,
unsigned int N )
{
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.
\return
An \c iterator_range delimiting the match.
Returned iterator is either \c CollectionT::iterator or
\c CollectionT::const_iterator, depending on the constness of
Returned iterator is either \c RangeT::iterator or
\c RangeT::const_iterator, depending on the constness of
the input parameter.
*/
template<typename CollectionT, typename FinderT>
template<typename RangeT, typename FinderT>
inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type>
BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
find(
CollectionT& Input,
RangeT& Input,
FinderT Finder)
{
return Finder(begin(Input),end(Input));
@ -66,18 +66,18 @@ namespace boost {
\param Search A substring to be searched for.
\return
An \c iterator_range delimiting the match.
Returned iterator is either \c CollectionT::iterator or
\c CollectionT::const_iterator, depending on the constness of
Returned iterator is either \c RangeT::iterator or
\c RangeT::const_iterator, depending on the constness of
the input parameter.
\note This function provides the strong exception-safety guarantee
*/
template<typename Collection1T, typename Collection2T>
template<typename Range1T, typename Range2T>
inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<Collection1T>::type>
BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
find_first(
Collection1T& Input,
const Collection2T& Search)
Range1T& Input,
const Range2T& Search)
{
return first_finder(Search)(
begin(Input),end(Input));
@ -93,18 +93,18 @@ namespace boost {
\param Loc A locale used for case insensitive comparison
\return
An \c iterator_range delimiting the match.
Returned iterator is either \c Collection1T::iterator or
\c Collection1T::const_iterator, depending on the constness of
Returned iterator is either \c Range1T::iterator or
\c Range1T::const_iterator, depending on the constness of
the input parameter.
\note This function provides the strong exception-safety guarantee
*/
template<typename Collection1T, typename Collection2T>
template<typename Range1T, typename Range2T>
inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<Collection1T>::type>
BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
ifind_first(
Collection1T& Input,
const Collection2T& Search,
Range1T& Input,
const Range2T& Search,
const std::locale& Loc=std::locale())
{
return first_finder(Search,is_iequal(Loc))(
@ -121,18 +121,18 @@ namespace boost {
\param Search A substring to be searched for.
\return
An \c iterator_range delimiting the match.
Returned iterator is either \c Collection1T::iterator or
\c Collection1T::const_iterator, depending on the constness of
Returned iterator is either \c Range1T::iterator or
\c Range1T::const_iterator, depending on the constness of
the input parameter.
\note This function provides the strong exception-safety guarantee
*/
template<typename Collection1T, typename Collection2T>
template<typename Range1T, typename Range2T>
inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<Collection1T>::type>
BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
find_last(
Collection1T& Input,
const Collection2T& Search)
Range1T& Input,
const Range2T& Search)
{
return last_finder(Search)(
begin(Input),end(Input));
@ -148,18 +148,18 @@ namespace boost {
\param Loc A locale used for case insensitive comparison
\return
An \c iterator_range delimiting the match.
Returned iterator is either \c Collection1T::iterator or
\c Collection1T::const_iterator, depending on the constness of
Returned iterator is either \c Range1T::iterator or
\c Range1T::const_iterator, depending on the constness of
the input parameter.
\note This function provides the strong exception-safety guarantee
*/
template<typename Collection1T, typename Collection2T>
template<typename Range1T, typename Range2T>
inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<Collection1T>::type>
BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
ifind_last(
Collection1T& Input,
const Collection2T& Search,
Range1T& Input,
const Range2T& Search,
const std::locale& Loc=std::locale())
{
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.
\return
An \c iterator_range delimiting the match.
Returned iterator is either \c Collection1T::iterator or
\c Collection1T::const_iterator, depending on the constness of
Returned iterator is either \c Range1T::iterator or
\c Range1T::const_iterator, depending on the constness of
the input parameter.
*/
template<typename Collection1T, typename Collection2T>
template<typename Range1T, typename Range2T>
inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<Collection1T>::type>
BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
find_nth(
Collection1T& Input,
const Collection2T& Search,
Range1T& Input,
const Range2T& Search,
unsigned int Nth)
{
return nth_finder(Search,Nth)(
@ -205,19 +205,19 @@ namespace boost {
\param Loc A locale used for case insensitive comparison
\return
An \c iterator_range delimiting the match.
Returned iterator is either \c Collection1T::iterator or
\c Collection1T::const_iterator, depending on the constness of
Returned iterator is either \c Range1T::iterator or
\c Range1T::const_iterator, depending on the constness of
the input parameter.
\note This function provides the strong exception-safety guarantee
*/
template<typename Collection1T, typename Collection2T>
template<typename Range1T, typename Range2T>
inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<Collection1T>::type>
BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
ifind_nth(
Collection1T& Input,
const Collection2T& Search,
Range1T& Input,
const Range2T& Search,
unsigned int Nth,
const std::locale& Loc=std::locale())
{
@ -237,17 +237,17 @@ namespace boost {
\param N Length of the head
\return
An \c iterator_range delimiting the match.
Returned iterator is either \c Collection1T::iterator or
\c Collection1T::const_iterator, depending on the constness of
Returned iterator is either \c Range1T::iterator or
\c Range1T::const_iterator, depending on the constness of
the input parameter.
\note This function provides the strong exception-safety guarantee
*/
template<typename CollectionT>
template<typename RangeT>
inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type>
BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
find_head(
CollectionT& Input,
RangeT& Input,
unsigned int N)
{
return head_finder(N)(
@ -266,18 +266,18 @@ namespace boost {
\param N Length of the tail
\return
An \c iterator_range delimiting the match.
Returned iterator is either \c CollectionT::iterator or
\c CollectionT::const_iterator, depending on the constness of
Returned iterator is either \c RangeT::iterator or
\c RangeT::const_iterator, depending on the constness of
the input parameter.
\note This function provides the strong exception-safety guarantee
*/
template<typename CollectionT>
template<typename RangeT>
inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type>
BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
find_tail(
CollectionT& Input,
RangeT& Input,
unsigned int N)
{
return tail_finder(N)(
@ -297,17 +297,17 @@ namespace boost {
\param eCompress Enable/Disable compressing of adjacent tokens
\return
An \c iterator_range delimiting the match.
Returned iterator is either \c CollectionT::iterator or
\c CollectionT::const_iterator, depending on the constness of
Returned iterator is either \c RangeT::iterator or
\c RangeT::const_iterator, depending on the constness of
the input parameter.
\note This function provides the strong exception-safety guarantee
*/
template<typename CollectionT, typename PredicateT>
template<typename RangeT, typename PredicateT>
inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type>
BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
find_token(
CollectionT& Input,
RangeT& Input,
PredicateT Pred,
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<
typename OutputIteratorT,
typename CollectionT,
typename RangeT,
typename FinderT,
typename FormatterT>
inline OutputIteratorT find_format_copy(
OutputIteratorT Output,
const CollectionT& Input,
const RangeT& Input,
FinderT Finder,
FormatterT Formatter )
{
// Concept check
function_requires<
FinderConcept<FinderT,
BOOST_STRING_TYPENAME range_const_iterator<CollectionT>::type> >();
BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
function_requires<
FormatterConcept<
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(
Output,
@ -161,23 +161,23 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename CollectionT,
typename RangeT,
typename FinderT,
typename FormatterT>
inline OutputIteratorT find_format_all_copy(
OutputIteratorT Output,
const CollectionT& Input,
const RangeT& Input,
FinderT Finder,
FormatterT Formatter)
{
// Concept check
function_requires<
FinderConcept<FinderT,
BOOST_STRING_TYPENAME range_const_iterator<CollectionT>::type> >();
BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
function_requires<
FormatterConcept<
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(
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
and a collection.
*/
template<typename FinderT, typename CollectionT>
template<typename FinderT, typename RangeT>
find_iterator(
CollectionT& Col,
RangeT& Col,
FinderT Finder ) :
detail::find_iterator_base<IteratorT>(Finder,0),
m_Match(begin(Col),begin(Col)),
@ -178,14 +178,14 @@ namespace boost {
/*!
* Construct a find iterator to iterate through the specified string
*/
template<typename CollectionT, typename FinderT>
template<typename RangeT, typename FinderT>
inline find_iterator<
BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type>
BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
make_find_iterator(
CollectionT& Collection,
RangeT& Collection,
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);
}
@ -273,9 +273,9 @@ namespace boost {
Construct new split_iterator for a given finder
and a collection.
*/
template<typename FinderT, typename CollectionT>
template<typename FinderT, typename RangeT>
split_iterator(
CollectionT& Col,
RangeT& Col,
FinderT Finder ) :
detail::find_iterator_base<IteratorT>(Finder,0),
m_Match(begin(Col),begin(Col)),
@ -354,14 +354,14 @@ namespace boost {
/*!
* Construct a split iterator to iterate through the specified collection
*/
template<typename CollectionT, typename FinderT>
template<typename RangeT, typename FinderT>
inline split_iterator<
BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type>
BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
make_split_iterator(
CollectionT& Collection,
RangeT& Collection,
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);
}

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
\return An instance of the \c const_formatter object.
*/
template<typename CollectionT>
inline detail::const_formatF<CollectionT>
const_formatter(const CollectionT& Format)
template<typename RangeT>
inline detail::const_formatF<RangeT>
const_formatter(const RangeT& Format)
{
return detail::const_formatF<CollectionT>(Format);
return detail::const_formatF<RangeT>(Format);
}
//! Identity formatter
@ -54,11 +54,11 @@ namespace boost {
\return An instance of the \c identity_formatter object.
*/
template<typename CollectionT>
inline detail::identity_formatF<CollectionT>
template<typename RangeT>
inline detail::identity_formatF<RangeT>
identity_formatter()
{
return detail::identity_formatF<CollectionT>();
return detail::identity_formatF<RangeT>();
}
//! Empty formatter
@ -70,13 +70,13 @@ namespace boost {
resulting empty_container<>.
\return An instance of the \c empty_formatter object.
*/
template<typename CollectionT>
template<typename RangeT>
inline detail::empty_formatF<
BOOST_STRING_TYPENAME range_value<CollectionT>::type>
empty_formatter(const CollectionT&)
BOOST_STRING_TYPENAME range_value<RangeT>::type>
empty_formatter(const RangeT&)
{
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<
typename SequenceSequenceT,
typename CollectionT,
typename RangeT,
typename FinderT >
inline SequenceSequenceT&
iter_find(
SequenceSequenceT& Result,
CollectionT& Input,
RangeT& Input,
FinderT Finder )
{
function_requires<
FinderConcept<FinderT,
BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type> >();
BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type> >();
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 detail::copy_iterator_rangeF<
BOOST_STRING_TYPENAME
@ -131,20 +131,20 @@ namespace boost {
*/
template<
typename SequenceSequenceT,
typename CollectionT,
typename RangeT,
typename FinderT >
inline SequenceSequenceT&
iter_split(
SequenceSequenceT& Result,
CollectionT& Input,
RangeT& Input,
FinderT Finder )
{
function_requires<
FinderConcept<FinderT,
BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type> >();
BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type> >();
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 detail::copy_iterator_rangeF<
BOOST_STRING_TYPENAME

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

@ -38,7 +38,7 @@ namespace boost {
//! '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.
When the optional predicate is specified, it is used for character-wise
comparison.
@ -50,16 +50,16 @@ namespace boost {
\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(
const Collection1T& Input,
const Collection2T& Test,
const Range1T& Input,
const Range2T& Test,
PredicateT Comp)
{
typedef BOOST_STRING_TYPENAME
range_const_iterator<Collection1T>::type Iterator1T;
range_const_iterator<Range1T>::type Iterator1T;
typedef BOOST_STRING_TYPENAME
range_const_iterator<Collection2T>::type Iterator2T;
range_const_iterator<Range2T>::type Iterator2T;
Iterator1T InputEnd=end(Input);
Iterator2T TestEnd=end(Test);
@ -81,17 +81,17 @@ namespace boost {
/*!
\overload
*/
template<typename Collection1T, typename Collection2T>
template<typename Range1T, typename Range2T>
inline bool starts_with(
const Collection1T& Input,
const Collection2T& Test)
const Range1T& Input,
const Range2T& Test)
{
return starts_with(Input, Test, is_equal());
}
//! '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.
Elements are compared case insensitively.
@ -102,10 +102,10 @@ namespace boost {
\note This function provides the strong exception-safety guarantee
*/
template<typename Collection1T, typename Collection2T>
template<typename Range1T, typename Range2T>
inline bool istarts_with(
const Collection1T& Input,
const Collection2T& Test,
const Range1T& Input,
const Range2T& Test,
const std::locale& Loc=std::locale())
{
return starts_with(Input, Test, is_iequal(Loc));
@ -116,7 +116,7 @@ namespace boost {
//! '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.
When the optional predicate is specified, it is used for character-wise
comparison.
@ -129,14 +129,14 @@ namespace boost {
\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(
const Collection1T& Input,
const Collection2T& Test,
const Range1T& Input,
const Range2T& Test,
PredicateT Comp)
{
typedef BOOST_STRING_TYPENAME
range_const_iterator<Collection1T>::type Iterator1T;
range_const_iterator<Range1T>::type Iterator1T;
typedef BOOST_STRING_TYPENAME boost::detail::
iterator_traits<Iterator1T>::iterator_category category;
@ -155,10 +155,10 @@ namespace boost {
/*!
\overload
*/
template<typename Collection1T, typename Collection2T>
template<typename Range1T, typename Range2T>
inline bool ends_with(
const Collection1T& Input,
const Collection2T& Test)
const Range1T& Input,
const Range2T& Test)
{
return ends_with(Input, Test, is_equal());
}
@ -176,10 +176,10 @@ namespace boost {
\note This function provides the strong exception-safety guarantee
*/
template<typename Collection1T, typename Collection2T>
template<typename Range1T, typename Range2T>
inline bool iends_with(
const Collection1T& Input,
const Collection2T& Test,
const Range1T& Input,
const Range2T& Test,
const std::locale& Loc=std::locale())
{
return ends_with(Input, Test, is_iequal(Loc));
@ -200,10 +200,10 @@ namespace boost {
\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(
const Collection1T& Input,
const Collection2T& Test,
const Range1T& Input,
const Range2T& Test,
PredicateT Comp)
{
if (empty(Test))
@ -221,10 +221,10 @@ namespace boost {
/*!
\overload
*/
template<typename Collection1T, typename Collection2T>
template<typename Range1T, typename Range2T>
inline bool contains(
const Collection1T& Input,
const Collection2T& Test)
const Range1T& Input,
const Range2T& Test)
{
return contains(Input, Test, is_equal());
}
@ -241,10 +241,10 @@ namespace boost {
\note This function provides the strong exception-safety guarantee
*/
template<typename Collection1T, typename Collection2T>
template<typename Range1T, typename Range2T>
inline bool icontains(
const Collection1T& Input,
const Collection2T& Test,
const Range1T& Input,
const Range2T& Test,
const std::locale& Loc=std::locale())
{
return contains(Input, Test, is_iequal(Loc));
@ -268,16 +268,16 @@ namespace boost {
\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(
const Collection1T& Input,
const Collection2T& Test,
const Range1T& Input,
const Range2T& Test,
PredicateT Comp)
{
typedef BOOST_STRING_TYPENAME
range_const_iterator<Collection1T>::type Iterator1T;
range_const_iterator<Range1T>::type Iterator1T;
typedef BOOST_STRING_TYPENAME
range_const_iterator<Collection2T>::type Iterator2T;
range_const_iterator<Range2T>::type Iterator2T;
Iterator1T InputEnd=end(Input);
Iterator2T TestEnd=end(Test);
@ -299,10 +299,10 @@ namespace boost {
/*!
\overload
*/
template<typename Collection1T, typename Collection2T>
template<typename Range1T, typename Range2T>
inline bool equals(
const Collection1T& Input,
const Collection2T& Test)
const Range1T& Input,
const Range2T& Test)
{
return equals(Input, Test, is_equal());
}
@ -322,10 +322,10 @@ namespace boost {
\note This function provides the strong exception-safety guarantee
*/
template<typename Collection1T, typename Collection2T>
template<typename Range1T, typename Range2T>
inline bool iequals(
const Collection1T& Input,
const Collection2T& Test,
const Range1T& Input,
const Range2T& Test,
const std::locale& Loc=std::locale())
{
return equals(Input, Test, is_iequal(Loc));
@ -344,13 +344,13 @@ namespace boost {
\note This function provides the strong exception-safety guarantee
*/
template<typename CollectionT, typename PredicateT>
template<typename RangeT, typename PredicateT>
inline bool all(
const CollectionT& Input,
const RangeT& Input,
PredicateT Pred)
{
typedef BOOST_STRING_TYPENAME
range_const_iterator<CollectionT>::type Iterator1T;
range_const_iterator<RangeT>::type Iterator1T;
Iterator1T InputEnd=end(Input);
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
\return
An \c iterator_range delimiting the match.
Returned iterator is either \c InputContainerT::iterator or
\c InputContainerT::const_iterator, depending on the constness of
Returned iterator is either \c RangeT::iterator or
\c RangeT::const_iterator, depending on the constness of
the input parameter.
\note This function provides the strong exception-safety guarantee
*/
template<
typename CollectionT,
typename RangeT,
typename CharT,
typename RegexTraitsT>
inline iterator_range<
BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type >
BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type >
find_regex(
CollectionT& Input,
RangeT& Input,
const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default )
{
@ -83,13 +83,13 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename CollectionT,
typename RangeT,
typename CharT,
typename RegexTraitsT,
typename FormatStringTraitsT, typename FormatStringAllocatorT >
inline OutputIteratorT replace_regex_copy(
OutputIteratorT Output,
const CollectionT& Input,
const RangeT& Input,
const basic_regex<CharT, RegexTraitsT>& Rx,
const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
match_flag_type Flags=match_default | format_default )
@ -169,13 +169,13 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename CollectionT,
typename RangeT,
typename CharT,
typename RegexTraitsT,
typename FormatStringTraitsT, typename FormatStringAllocatorT >
inline OutputIteratorT replace_all_regex_copy(
OutputIteratorT Output,
const CollectionT& Input,
const RangeT& Input,
const basic_regex<CharT, RegexTraitsT>& Rx,
const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
match_flag_type Flags=match_default | format_default )
@ -254,12 +254,12 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename CollectionT,
typename RangeT,
typename CharT,
typename RegexTraitsT >
inline OutputIteratorT erase_regex_copy(
OutputIteratorT Output,
const CollectionT& Input,
const RangeT& Input,
const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default )
{
@ -333,12 +333,12 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename CollectionT,
typename RangeT,
typename CharT,
typename RegexTraitsT >
inline OutputIteratorT erase_all_regex_copy(
OutputIteratorT Output,
const CollectionT& Input,
const RangeT& Input,
const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default )
{
@ -418,12 +418,12 @@ namespace boost {
*/
template<
typename SequenceSequenceT,
typename CollectionT,
typename RangeT,
typename CharT,
typename RegexTraitsT >
inline SequenceSequenceT& find_all_regex(
SequenceSequenceT& Result,
const CollectionT& Input,
const RangeT& Input,
const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default )
{
@ -459,12 +459,12 @@ namespace boost {
*/
template<
typename SequenceSequenceT,
typename CollectionT,
typename RangeT,
typename CharT,
typename RegexTraitsT >
inline SequenceSequenceT& split_regex(
SequenceSequenceT& Result,
const CollectionT& Input,
const RangeT& Input,
const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default )
{

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

@ -50,15 +50,15 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T>
typename Range1T,
typename Range2T>
inline OutputIteratorT replace_range_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Range1T& Input,
const iterator_range<
BOOST_STRING_TYPENAME
range_const_iterator<Collection1T>::type>& SearchRange,
const Collection2T& Format)
range_const_iterator<Range1T>::type>& SearchRange,
const Range2T& Format)
{
return find_format_copy(
Output,
@ -71,13 +71,13 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline SequenceT replace_range_copy(
const SequenceT& Input,
const iterator_range<
BOOST_STRING_TYPENAME
range_const_iterator<SequenceT>::type>& SearchRange,
const CollectionT& Format)
const RangeT& Format)
{
return find_format_copy(
Input,
@ -94,13 +94,13 @@ namespace boost {
\param SearchRange A range in the input to be substituted
\param Format A substitute string
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline void replace_range(
SequenceT& Input,
const iterator_range<
BOOST_STRING_TYPENAME
range_iterator<SequenceT>::type>& SearchRange,
const CollectionT& Format)
const RangeT& Format)
{
find_format(
Input,
@ -128,14 +128,14 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T,
typename Collection3T>
typename Range1T,
typename Range2T,
typename Range3T>
inline OutputIteratorT replace_first_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Collection2T& Search,
const Collection3T& Format)
const Range1T& Input,
const Range2T& Search,
const Range3T& Format)
{
return find_format_copy(
Output,
@ -148,11 +148,11 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename Collection1T, typename Collection2T>
template<typename SequenceT, typename Range1T, typename Range2T>
inline SequenceT replace_first_copy(
const SequenceT& Input,
const Collection1T& Search,
const Collection2T& Format )
const Range1T& Search,
const Range2T& Format )
{
return find_format_copy(
Input,
@ -169,11 +169,11 @@ namespace boost {
\param Search A substring to be searched for
\param Format A substitute string
*/
template<typename SequenceT, typename Collection1T, typename Collection2T>
template<typename SequenceT, typename Range1T, typename Range2T>
inline void replace_first(
SequenceT& Input,
const Collection1T& Search,
const Collection2T& Format )
const Range1T& Search,
const Range2T& Format )
{
find_format(
Input,
@ -203,14 +203,14 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T,
typename Collection3T>
typename Range1T,
typename Range2T,
typename Range3T>
inline OutputIteratorT ireplace_first_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Collection2T& Search,
const Collection3T& Format,
const Range1T& Input,
const Range2T& Search,
const Range3T& Format,
const std::locale& Loc=std::locale() )
{
return find_format_copy(
@ -224,11 +224,11 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename Collection2T, typename Collection1T>
template<typename SequenceT, typename Range2T, typename Range1T>
inline SequenceT ireplace_first_copy(
const SequenceT& Input,
const Collection2T& Search,
const Collection1T& Format,
const Range2T& Search,
const Range1T& Format,
const std::locale& Loc=std::locale() )
{
return find_format_copy(
@ -248,11 +248,11 @@ namespace boost {
\param Format A substitute string
\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(
SequenceT& Input,
const Collection1T& Search,
const Collection2T& Format,
const Range1T& Search,
const Range2T& Format,
const std::locale& Loc=std::locale() )
{
find_format(
@ -281,14 +281,14 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T,
typename Collection3T>
typename Range1T,
typename Range2T,
typename Range3T>
inline OutputIteratorT replace_last_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Collection2T& Search,
const Collection3T& Format )
const Range1T& Input,
const Range2T& Search,
const Range3T& Format )
{
return find_format_copy(
Output,
@ -301,11 +301,11 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename Collection1T, typename Collection2T>
template<typename SequenceT, typename Range1T, typename Range2T>
inline SequenceT replace_last_copy(
const SequenceT& Input,
const Collection1T& Search,
const Collection2T& Format )
const Range1T& Search,
const Range2T& Format )
{
return find_format_copy(
Input,
@ -322,11 +322,11 @@ namespace boost {
\param Search A substring to be searched for
\param Format A substitute string
*/
template<typename SequenceT, typename Collection1T, typename Collection2T>
template<typename SequenceT, typename Range1T, typename Range2T>
inline void replace_last(
SequenceT& Input,
const Collection1T& Search,
const Collection2T& Format )
const Range1T& Search,
const Range2T& Format )
{
find_format(
Input,
@ -356,14 +356,14 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T,
typename Collection3T>
typename Range1T,
typename Range2T,
typename Range3T>
inline OutputIteratorT ireplace_last_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Collection2T& Search,
const Collection3T& Format,
const Range1T& Input,
const Range2T& Search,
const Range3T& Format,
const std::locale& Loc=std::locale() )
{
return find_format_copy(
@ -377,11 +377,11 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename Collection1T, typename Collection2T>
template<typename SequenceT, typename Range1T, typename Range2T>
inline SequenceT ireplace_last_copy(
const SequenceT& Input,
const Collection1T& Search,
const Collection2T& Format,
const Range1T& Search,
const Range2T& Format,
const std::locale& Loc=std::locale() )
{
return find_format_copy(
@ -402,11 +402,11 @@ namespace boost {
\param Loc A locale used for case insensitive comparison
\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(
SequenceT& Input,
const Collection1T& Search,
const Collection2T& Format,
const Range1T& Search,
const Range2T& Format,
const std::locale& Loc=std::locale() )
{
find_format(
@ -436,15 +436,15 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T,
typename Collection3T>
typename Range1T,
typename Range2T,
typename Range3T>
inline OutputIteratorT replace_nth_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Collection2T& Search,
const Range1T& Input,
const Range2T& Search,
unsigned int Nth,
const Collection3T& Format )
const Range3T& Format )
{
return find_format_copy(
Output,
@ -457,12 +457,12 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename Collection1T, typename Collection2T>
template<typename SequenceT, typename Range1T, typename Range2T>
inline SequenceT replace_nth_copy(
const SequenceT& Input,
const Collection1T& Search,
const Range1T& Search,
unsigned int Nth,
const Collection2T& Format )
const Range2T& Format )
{
return find_format_copy(
Input,
@ -480,12 +480,12 @@ namespace boost {
\param Nth An index of the match to be replaced. The index is 0-based.
\param Format A substitute string
*/
template<typename SequenceT, typename Collection1T, typename Collection2T>
template<typename SequenceT, typename Range1T, typename Range2T>
inline void replace_nth(
SequenceT& Input,
const Collection1T& Search,
const Range1T& Search,
unsigned int Nth,
const Collection2T& Format )
const Range2T& Format )
{
find_format(
Input,
@ -516,15 +516,15 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T,
typename Collection3T>
typename Range1T,
typename Range2T,
typename Range3T>
inline OutputIteratorT ireplace_nth_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Collection2T& Search,
const Range1T& Input,
const Range2T& Search,
unsigned int Nth,
const Collection3T& Format,
const Range3T& Format,
const std::locale& Loc=std::locale() )
{
return find_format_copy(
@ -538,12 +538,12 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename Collection1T, typename Collection2T>
template<typename SequenceT, typename Range1T, typename Range2T>
inline SequenceT ireplace_nth_copy(
const SequenceT& Input,
const Collection1T& Search,
const Range1T& Search,
unsigned int Nth,
const Collection2T& Format,
const Range2T& Format,
const std::locale& Loc=std::locale() )
{
return find_format_copy(
@ -564,12 +564,12 @@ namespace boost {
\param Format A substitute string
\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(
SequenceT& Input,
const Collection1T& Search,
const Range1T& Search,
unsigned int Nth,
const Collection2T& Format,
const Range2T& Format,
const std::locale& Loc=std::locale() )
{
find_format(
@ -598,14 +598,14 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T,
typename Collection3T>
typename Range1T,
typename Range2T,
typename Range3T>
inline OutputIteratorT replace_all_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Collection2T& Search,
const Collection3T& Format )
const Range1T& Input,
const Range2T& Search,
const Range3T& Format )
{
return find_format_all_copy(
Output,
@ -618,11 +618,11 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename Collection1T, typename Collection2T>
template<typename SequenceT, typename Range1T, typename Range2T>
inline SequenceT replace_all_copy(
const SequenceT& Input,
const Collection1T& Search,
const Collection2T& Format )
const Range1T& Search,
const Range2T& Format )
{
return find_format_all_copy(
Input,
@ -640,11 +640,11 @@ namespace boost {
\param Format A substitute string
\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(
SequenceT& Input,
const Collection1T& Search,
const Collection2T& Format )
const Range1T& Search,
const Range2T& Format )
{
find_format_all(
Input,
@ -674,14 +674,14 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T,
typename Collection3T>
typename Range1T,
typename Range2T,
typename Range3T>
inline OutputIteratorT ireplace_all_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Collection2T& Search,
const Collection3T& Format,
const Range1T& Input,
const Range2T& Search,
const Range3T& Format,
const std::locale& Loc=std::locale() )
{
return find_format_all_copy(
@ -695,11 +695,11 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename Collection1T, typename Collection2T>
template<typename SequenceT, typename Range1T, typename Range2T>
inline SequenceT ireplace_all_copy(
const SequenceT& Input,
const Collection1T& Search,
const Collection2T& Format,
const Range1T& Search,
const Range2T& Format,
const std::locale& Loc=std::locale() )
{
return find_format_all_copy(
@ -719,11 +719,11 @@ namespace boost {
\param Format A substitute string
\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(
SequenceT& Input,
const Collection1T& Search,
const Collection2T& Format,
const Range1T& Search,
const Range2T& Format,
const std::locale& Loc=std::locale() )
{
find_format_all(
@ -754,13 +754,13 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T>
typename Range1T,
typename Range2T>
inline OutputIteratorT replace_head_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Range1T& Input,
unsigned int N,
const Collection2T& Format )
const Range2T& Format )
{
return find_format_copy(
Output,
@ -773,11 +773,11 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline SequenceT replace_head_copy(
const SequenceT& Input,
unsigned int N,
const CollectionT& Format )
const RangeT& Format )
{
return find_format_copy(
Input,
@ -796,11 +796,11 @@ namespace boost {
\param N Length of the head
\param Format A substitute string
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline void replace_head(
SequenceT& Input,
unsigned int N,
const CollectionT& Format )
const RangeT& Format )
{
find_format(
Input,
@ -830,13 +830,13 @@ namespace boost {
*/
template<
typename OutputIteratorT,
typename Collection1T,
typename Collection2T>
typename Range1T,
typename Range2T>
inline OutputIteratorT replace_tail_copy(
OutputIteratorT Output,
const Collection1T& Input,
const Range1T& Input,
unsigned int N,
const Collection2T& Format )
const Range2T& Format )
{
return find_format_copy(
Output,
@ -849,11 +849,11 @@ namespace boost {
/*!
\overload
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline SequenceT replace_tail_copy(
const SequenceT& Input,
unsigned int N,
const CollectionT& Format )
const RangeT& Format )
{
return find_format_copy(
Input,
@ -872,11 +872,11 @@ namespace boost {
\param N Length of the tail
\param Format A substitute string
*/
template<typename SequenceT, typename CollectionT>
template<typename SequenceT, typename RangeT>
inline void replace_tail(
SequenceT& Input,
unsigned int N,
const CollectionT& Format )
const RangeT& Format )
{
find_format(
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
*/
template< typename SequenceSequenceT, typename Collection1T, typename Collection2T >
template< typename SequenceSequenceT, typename Range1T, typename Range2T >
inline SequenceSequenceT& find_all(
SequenceSequenceT& Result,
Collection1T& Input,
const Collection2T& Search)
Range1T& Input,
const Range2T& Search)
{
return iter_find(
Result,
@ -92,11 +92,11 @@ namespace boost {
\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(
SequenceSequenceT& Result,
Collection1T& Input,
const Collection2T& Search,
Range1T& Input,
const Range2T& Search,
const std::locale& Loc=std::locale() )
{
return iter_find(
@ -135,10 +135,10 @@ namespace boost {
\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(
SequenceSequenceT& Result,
CollectionT& Input,
RangeT& Input,
PredicateT Pred,
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
*/
template<typename OutputIteratorT, typename CollectionT, typename PredicateT>
template<typename OutputIteratorT, typename RangeT, typename PredicateT>
inline OutputIteratorT trim_left_copy_if(
OutputIteratorT Output,
const CollectionT& Input,
const RangeT& Input,
PredicateT IsSpace)
{
std::copy(
@ -160,10 +160,10 @@ namespace boost {
\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(
OutputIteratorT Output,
const CollectionT& Input,
const RangeT& Input,
PredicateT IsSpace )
{
std::copy(
@ -270,14 +270,14 @@ namespace boost {
\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(
OutputIteratorT Output,
const CollectionT& Input,
const RangeT& Input,
PredicateT IsSpace)
{
BOOST_STRING_TYPENAME
range_const_iterator<CollectionT>::type TrimEnd=
range_const_iterator<RangeT>::type TrimEnd=
detail::trim_end(
begin(Input),
end(Input),