Compare commits

..

27 Commits

Author SHA1 Message Date
4c72b78551 merged from trunk
[SVN r49607]
2008-11-06 00:15:47 +00:00
6702b04019 merged from trunk
[SVN r48605]
2008-09-05 04:13:30 +00:00
4e17ef2b40 merged from trunk
[SVN r47983]
2008-08-05 05:39:57 +00:00
f62e23a14c merged from trunk
[SVN r45985]
2008-05-31 19:31:01 +00:00
8ff3ace362 merged from trunk
[SVN r45289]
2008-05-11 18:27:27 +00:00
a232c948bf post-review proto version
[SVN r44061]
2008-04-05 18:00:00 +00:00
a389d768c4 Fix broken copyright urls. Fixes #1573.
[SVN r43422]
2008-02-27 18:51:14 +00:00
90fca39906 Point links to the pages that used to be in 'more' to the site.
[SVN r43210]
2008-02-10 15:02:17 +00:00
5b24f31486 merging changes from 1.34
[SVN r40698]
2007-11-02 21:00:08 +00:00
b25d6511b3 merging changes from 1.34
[SVN r40697]
2007-11-02 20:55:26 +00:00
1541a554f5 changed range_result_iterator to range_iterator
[SVN r40518]
2007-10-27 22:52:29 +00:00
7a97b3390e Added missing include.
[SVN r39586]
2007-09-28 07:19:29 +00:00
6e5a7497ae Added missing include.
[SVN r39519]
2007-09-25 08:46:31 +00:00
f0b8b60379 Update
[SVN r38522]
2007-08-08 19:24:04 +00:00
66019abb2f Update
[SVN r38521]
2007-08-08 19:23:38 +00:00
8758222006 Remove V1 Jamfiles
[SVN r38516]
2007-08-08 19:02:26 +00:00
4eef56761a find/split iterator tests added
[SVN r38126]
2007-07-01 22:24:29 +00:00
b94a3fbfba adapting to new range interface
[SVN r38125]
2007-07-01 22:23:55 +00:00
614cc2ebab adapting to new range interface
[SVN r38123]
2007-07-01 13:29:56 +00:00
869660ed14 adapted to the new range interface
[SVN r38122]
2007-07-01 13:12:57 +00:00
777f30780e Fix broken build of docs, it was missing a dependency to the doxygen docs.
[SVN r37466]
2007-04-17 17:19:25 +00:00
26aa37733b Fix a few more references to *.boosbook instead of *.xml generated files.
[SVN r37465]
2007-04-17 17:13:35 +00:00
f1e60579c2 documentation typo fixed
[SVN r36843]
2007-01-30 07:59:28 +00:00
389dd3c863 Add copyright, license
[SVN r35905]
2006-11-07 19:11:57 +00:00
f23f61ae9b License added to the xml doc files
[SVN r34895]
2006-08-16 07:17:49 +00:00
608112b112 boost guidelines (mainly from inspect tool: tabs, license reference text, etc.)
[SVN r34752]
2006-07-27 10:27:37 +00:00
b21b54dc4e Applying patch from Nicola Musatti
[SVN r33709]
2006-04-16 09:46:34 +00:00
40 changed files with 611 additions and 821 deletions

22
CMakeLists.txt Normal file
View File

@ -0,0 +1,22 @@
#----------------------------------------------------------------------------
# This file was automatically generated from the original CMakeLists.txt file
# Add a variable to hold the headers for the library
set (lib_headers
algorithm
)
# Add a library target to the build system
boost_library_project(
algorithm
# SRCDIRS
TESTDIRS minmax/test string/test
HEADERS ${lib_headers}
# DOCDIRS
DESCRIPTION "A library of various algorithms."
MODULARIZED
AUTHORS "Pavol Droba <droba -at- topmail.sk>"
"Herve Bronnimann <hbr -at- poly.edu>"
# MAINTAINERS
)

View File

@ -59,7 +59,7 @@ namespace boost {
{
return ::boost::algorithm::detail::transform_range_copy(
Output,
::boost::as_literal(Input),
as_literal(Input),
::boost::algorithm::detail::to_lowerF<
typename range_value<RangeT>::type >(Loc));
}
@ -93,7 +93,7 @@ namespace boost {
const std::locale& Loc=std::locale())
{
::boost::algorithm::detail::transform_range(
::boost::as_literal(Input),
as_literal(Input),
::boost::algorithm::detail::to_lowerF<
typename range_value<WritableRangeT>::type >(Loc));
}
@ -124,7 +124,7 @@ namespace boost {
{
return ::boost::algorithm::detail::transform_range_copy(
Output,
::boost::as_literal(Input),
as_literal(Input),
::boost::algorithm::detail::to_upperF<
typename range_value<RangeT>::type >(Loc));
}
@ -158,7 +158,7 @@ namespace boost {
const std::locale& Loc=std::locale())
{
::boost::algorithm::detail::transform_range(
::boost::as_literal(Input),
as_literal(Input),
::boost::algorithm::detail::to_upperF<
typename range_value<WritableRangeT>::type >(Loc));
}

View File

@ -202,7 +202,7 @@ namespace boost {
BOOST_STRING_TYPENAME range_value<RangeT>::type>
is_any_of( const RangeT& Set )
{
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_set(boost::as_literal(Set));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_set(as_literal(Set));
return detail::is_any_ofF<BOOST_STRING_TYPENAME range_value<RangeT>::type>(lit_set);
}

View File

@ -31,7 +31,7 @@ namespace boost {
struct to_lowerF : public std::unary_function<CharT, CharT>
{
// Constructor
to_lowerF( const std::locale& Loc ) : m_Loc( &Loc ) {}
to_lowerF( const std::locale& Loc ) : m_Loc( Loc ) {}
// Operation
CharT operator ()( CharT Ch ) const
@ -39,11 +39,11 @@ namespace boost {
#if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
return std::tolower( Ch);
#else
return std::tolower<CharT>( Ch, *m_Loc );
return std::tolower<CharT>( Ch, m_Loc );
#endif
}
private:
const std::locale* m_Loc;
const std::locale& m_Loc;
};
// a toupper functor
@ -51,7 +51,7 @@ namespace boost {
struct to_upperF : public std::unary_function<CharT, CharT>
{
// Constructor
to_upperF( const std::locale& Loc ) : m_Loc( &Loc ) {}
to_upperF( const std::locale& Loc ) : m_Loc( Loc ) {}
// Operation
CharT operator ()( CharT Ch ) const
@ -59,11 +59,11 @@ namespace boost {
#if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
return std::toupper( Ch);
#else
return std::toupper<CharT>( Ch, *m_Loc );
return std::toupper<CharT>( Ch, m_Loc );
#endif
}
private:
const std::locale* m_Loc;
const std::locale& m_Loc;
};
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
@ -105,10 +105,10 @@ namespace boost {
FunctorT Functor)
{
return SequenceT(
::boost::make_transform_iterator(
make_transform_iterator(
::boost::begin(Input),
Functor),
::boost::make_transform_iterator(
make_transform_iterator(
::boost::end(Input),
Functor));
}

View File

@ -32,8 +32,8 @@ namespace boost {
struct is_classifiedF :
public predicate_facade<is_classifiedF>
{
// Boost.ResultOf support
typedef bool result_type;
// Boost.Lambda support
template <class Args> struct sig { typedef bool type; };
// Constructor from a locale
is_classifiedF(std::ctype_base::mask Type, std::locale const & Loc = std::locale()) :
@ -72,8 +72,8 @@ namespace boost {
typedef typename ::boost::remove_const<CharT>::type set_value_type;
public:
// Boost.ResultOf support
typedef bool result_type;
// Boost.Lambda support
template <class Args> struct sig { typedef bool type; };
// Constructor
template<typename RangeT>
@ -171,7 +171,7 @@ namespace boost {
// Check what kind of storage are we using right now
if(use_fixed_storage(m_Size))
{
// Using fixed storage, allocate new
// Using fixed storage, allocate new
set_value_type* pTemp=new set_value_type[Other.m_Size];
DestStorage=pTemp;
m_Storage.m_dynSet=pTemp;
@ -253,8 +253,8 @@ namespace boost {
struct is_from_rangeF :
public predicate_facade< is_from_rangeF<CharT> >
{
// Boost.ResultOf support
typedef bool result_type;
// Boost.Lambda support
template <class Args> struct sig { typedef bool type; };
// Constructor
is_from_rangeF( CharT From, CharT To ) : m_From(From), m_To(To) {}
@ -278,8 +278,8 @@ namespace boost {
{
public:
// Boost.ResultOf support
typedef bool result_type;
// Boost.Lambda support
template <class Args> struct sig { typedef bool type; };
// Constructor
pred_andF( Pred1T Pred1, Pred2T Pred2 ) :
@ -303,8 +303,8 @@ namespace boost {
public predicate_facade< pred_orF<Pred1T,Pred2T> >
{
public:
// Boost.ResultOf support
typedef bool result_type;
// Boost.Lambda support
template <class Args> struct sig { typedef bool type; };
// Constructor
pred_orF( Pred1T Pred1, Pred2T Pred2 ) :
@ -328,8 +328,8 @@ namespace boost {
public predicate_facade< pred_notF<PredT> >
{
public:
// Boost.ResultOf support
typedef bool result_type;
// Boost.Lambda support
template <class Args> struct sig { typedef bool type; };
// Constructor
pred_notF( PredT Pred ) : m_Pred(Pred) {}

View File

@ -24,7 +24,26 @@ namespace boost {
// find_format_copy (iterator variant) implementation -------------------------------//
template<
template<
typename OutputIteratorT,
typename InputT,
typename FormatterT,
typename FindResultT >
inline OutputIteratorT find_format_copy_impl(
OutputIteratorT Output,
const InputT& Input,
FormatterT Formatter,
const FindResultT& FindResult )
{
return find_format_copy_impl2(
Output,
Input,
Formatter,
FindResult,
Formatter(FindResult) );
}
template<
typename OutputIteratorT,
typename InputT,
typename FormatterT,
@ -49,48 +68,40 @@ namespace boost {
if ( !M )
{
// Match not found - return original sequence
Output = std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
return Output;
}
// Copy the beginning of the sequence
Output = std::copy( ::boost::begin(Input), ::boost::begin(M), Output );
std::copy( ::boost::begin(Input), ::boost::begin(M), Output );
// Format find result
// Copy formated result
Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
// Copy the rest of the sequence
Output = std::copy( M.end(), ::boost::end(Input), Output );
std::copy( M.end(), ::boost::end(Input), Output );
return Output;
}
template<
typename OutputIteratorT,
typename InputT,
typename FormatterT,
typename FindResultT >
inline OutputIteratorT find_format_copy_impl(
OutputIteratorT Output,
const InputT& Input,
FormatterT Formatter,
const FindResultT& FindResult )
{
if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
return ::boost::algorithm::detail::find_format_copy_impl2(
Output,
Input,
Formatter,
FindResult,
Formatter(FindResult) );
} else {
return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
}
}
// find_format_copy implementation --------------------------------------------------//
template<
template<
typename InputT,
typename FormatterT,
typename FindResultT >
inline InputT find_format_copy_impl(
const InputT& Input,
FormatterT Formatter,
const FindResultT& FindResult)
{
return find_format_copy_impl2(
Input,
Formatter,
FindResult,
Formatter(FindResult) );
}
template<
typename InputT,
typename FormatterT,
typename FindResultT,
@ -127,28 +138,24 @@ namespace boost {
return Output;
}
template<
typename InputT,
// replace implementation ----------------------------------------------------//
template<
typename InputT,
typename FormatterT,
typename FindResultT >
inline InputT find_format_copy_impl(
const InputT& Input,
inline void find_format_impl(
InputT& Input,
FormatterT Formatter,
const FindResultT& FindResult)
{
if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
return ::boost::algorithm::detail::find_format_copy_impl2(
Input,
Formatter,
FindResult,
Formatter(FindResult) );
} else {
return Input;
}
find_format_impl2(
Input,
Formatter,
FindResult,
Formatter(FindResult) );
}
// replace implementation ----------------------------------------------------//
template<
typename InputT,
typename FormatterT,
@ -176,25 +183,7 @@ namespace boost {
}
// Replace match
::boost::algorithm::detail::replace( Input, M.begin(), M.end(), M.format_result() );
}
template<
typename InputT,
typename FormatterT,
typename FindResultT >
inline void find_format_impl(
InputT& Input,
FormatterT Formatter,
const FindResultT& FindResult)
{
if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
::boost::algorithm::detail::find_format_impl2(
Input,
Formatter,
FindResult,
Formatter(FindResult) );
}
replace( Input, M.begin(), M.end(), M.format_result() );
}
} // namespace detail

View File

@ -24,7 +24,29 @@ namespace boost {
// find_format_all_copy (iterator variant) implementation ---------------------------//
template<
template<
typename OutputIteratorT,
typename InputT,
typename FinderT,
typename FormatterT,
typename FindResultT >
inline OutputIteratorT find_format_all_copy_impl(
OutputIteratorT Output,
const InputT& Input,
FinderT Finder,
FormatterT Formatter,
const FindResultT& FindResult )
{
return find_format_all_copy_impl2(
Output,
Input,
Finder,
Formatter,
FindResult,
Formatter(FindResult) );
}
template<
typename OutputIteratorT,
typename InputT,
typename FinderT,
@ -57,9 +79,9 @@ namespace boost {
while( M )
{
// Copy the beginning of the sequence
Output = std::copy( LastMatch, M.begin(), Output );
std::copy( LastMatch, M.begin(), Output );
// Copy formated result
Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
// Proceed to the next match
LastMatch=M.end();
@ -67,40 +89,33 @@ namespace boost {
}
// Copy the rest of the sequence
Output = std::copy( LastMatch, ::boost::end(Input), Output );
std::copy( LastMatch, ::boost::end(Input), Output );
return Output;
}
// find_format_all_copy implementation ----------------------------------------------//
template<
typename OutputIteratorT,
typename InputT,
typename InputT,
typename FinderT,
typename FormatterT,
typename FindResultT >
inline OutputIteratorT find_format_all_copy_impl(
OutputIteratorT Output,
inline InputT find_format_all_copy_impl(
const InputT& Input,
FinderT Finder,
FormatterT Formatter,
const FindResultT& FindResult )
{
if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
return ::boost::algorithm::detail::find_format_all_copy_impl2(
Output,
Input,
Finder,
Formatter,
FindResult,
Formatter(FindResult) );
} else {
return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
}
const FindResultT& FindResult)
{
return find_format_all_copy_impl2(
Input,
Finder,
Formatter,
FindResult,
Formatter(FindResult) );
}
// find_format_all_copy implementation ----------------------------------------------//
template<
template<
typename InputT,
typename FinderT,
typename FormatterT,
@ -144,36 +159,32 @@ namespace boost {
}
// Copy the rest of the sequence
::boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, ::boost::end(Input) );
insert( Output, ::boost::end(Output), LastMatch, ::boost::end(Input) );
return Output;
}
template<
typename InputT,
// find_format_all implementation ------------------------------------------------//
template<
typename InputT,
typename FinderT,
typename FormatterT,
typename FindResultT >
inline InputT find_format_all_copy_impl(
const InputT& Input,
inline void find_format_all_impl(
InputT& Input,
FinderT Finder,
FormatterT Formatter,
const FindResultT& FindResult)
FindResultT FindResult)
{
if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
return ::boost::algorithm::detail::find_format_all_copy_impl2(
Input,
Finder,
Formatter,
FindResult,
Formatter(FindResult) );
} else {
return Input;
}
find_format_all_impl2(
Input,
Finder,
Formatter,
FindResult,
Formatter(FindResult) );
}
// find_format_all implementation ------------------------------------------------//
template<
typename InputT,
typename FinderT,
@ -219,14 +230,14 @@ namespace boost {
SearchIt=M.end();
// Copy formated replace to the storage
::boost::algorithm::detail::copy_to_storage( Storage, M.format_result() );
copy_to_storage( Storage, M.format_result() );
// Find range for a next match
M=Finder( SearchIt, ::boost::end(Input) );
}
// process the last segment
InsertIt=::boost::algorithm::detail::process_segment(
InsertIt=process_segment(
Storage,
Input,
InsertIt,
@ -236,33 +247,12 @@ namespace boost {
if ( Storage.empty() )
{
// Truncate input
::boost::algorithm::detail::erase( Input, InsertIt, ::boost::end(Input) );
erase( Input, InsertIt, ::boost::end(Input) );
}
else
{
// Copy remaining data to the end of input
::boost::algorithm::detail::insert( Input, ::boost::end(Input), Storage.begin(), Storage.end() );
}
}
template<
typename InputT,
typename FinderT,
typename FormatterT,
typename FindResultT >
inline void find_format_all_impl(
InputT& Input,
FinderT Finder,
FormatterT Formatter,
FindResultT FindResult)
{
if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
::boost::algorithm::detail::find_format_all_impl2(
Input,
Finder,
Formatter,
FindResult,
Formatter(FindResult) );
insert( Input, ::boost::end(Input), Storage.begin(), Storage.end() );
}
}

View File

@ -52,9 +52,7 @@ namespace boost {
find_format_store& operator=( FindResultT FindResult )
{
iterator_range<ForwardIteratorT>::operator=(FindResult);
if( !this->empty() ) {
m_FormatResult=m_Formatter(FindResult);
}
m_FormatResult=m_Formatter(FindResult);
return *this;
}
@ -70,15 +68,6 @@ namespace boost {
const formatter_type& m_Formatter;
};
template<typename InputT, typename FindResultT>
bool check_find_result(InputT&, FindResultT& FindResult)
{
typedef BOOST_STRING_TYPENAME
range_const_iterator<InputT>::type input_iterator_type;
iterator_range<input_iterator_type> ResultRange(FindResult);
return !ResultRange.empty();
}
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
#pragma warning(pop)
#endif

View File

@ -382,7 +382,7 @@ namespace boost {
typedef BOOST_STRING_TYPENAME boost::detail::
iterator_traits<ForwardIteratorT>::iterator_category category;
return ::boost::algorithm::detail::find_head_impl( Begin, End, N, category() );
return find_head_impl( Begin, End, N, category() );
}
template< typename ForwardIteratorT >
@ -456,7 +456,7 @@ namespace boost {
typedef BOOST_STRING_TYPENAME boost::detail::
iterator_traits<ForwardIteratorT>::iterator_category category;
return ::boost::algorithm::detail::find_tail_impl( Begin, End, N, category() );
return find_tail_impl( Begin, End, N, category() );
}
@ -484,14 +484,14 @@ namespace boost {
{
if(m_N>=0)
{
return ::boost::algorithm::detail::find_head_impl( Begin, End, m_N );
return find_head_impl( Begin, End, m_N );
}
else
{
iterator_range<ForwardIteratorT> Res=
::boost::algorithm::detail::find_tail_impl( Begin, End, -m_N );
find_tail_impl( Begin, End, -m_N );
return ::boost::make_iterator_range(Begin, Res.begin());
return make_iterator_range(Begin, Res.begin());
}
}
@ -522,14 +522,14 @@ namespace boost {
{
if(m_N>=0)
{
return ::boost::algorithm::detail::find_tail_impl( Begin, End, m_N );
return find_tail_impl( Begin, End, m_N );
}
else
{
iterator_range<ForwardIteratorT> Res=
::boost::algorithm::detail::find_head_impl( Begin, End, -m_N );
find_head_impl( Begin, End, -m_N );
return ::boost::make_iterator_range(Res.end(), End);
return make_iterator_range(Res.end(), End);
}
}

View File

@ -98,7 +98,7 @@ namespace boost {
// instantiate match result
match_results<input_iterator_type> result;
// search for a match
if ( ::boost::regex_search( Begin, End, result, m_Rx, m_MatchFlags ) )
if ( regex_search( Begin, End, result, m_Rx, m_MatchFlags ) )
{
// construct a result
return result_type( result );

View File

@ -63,7 +63,7 @@ namespace boost {
iterator_range<ForwardIterator1T> Result
=last_finder(
::boost::make_iterator_range(SubBegin, SubEnd),
make_iterator_range(SubBegin, SubEnd),
Comp)(Begin, End);
return !Result.empty() && Result.end()==End;

View File

@ -68,7 +68,7 @@ namespace boost {
ForwardIteratorT SegmentEnd )
{
// Copy data from the storage until the beginning of the segment
ForwardIteratorT It=::boost::algorithm::detail::move_from_storage( Storage, InsertIt, SegmentBegin );
ForwardIteratorT It=move_from_storage( Storage, InsertIt, SegmentBegin );
// 3 cases are possible :
// a) Storage is empty, It==SegmentBegin
@ -125,7 +125,7 @@ namespace boost {
{
// Call replace to do the job
::boost::algorithm::detail::replace( Input, InsertIt, SegmentBegin, Storage );
replace( Input, InsertIt, SegmentBegin, Storage );
// Empty the storage
Storage.clear();
// Iterators were not changed, simply return the end of segment

View File

@ -41,7 +41,7 @@ namespace boost {
BOOST_STRING_TYPENAME InputT::iterator At,
const InsertT& Insert )
{
::boost::algorithm::detail::insert( Input, At, ::boost::begin(Insert), ::boost::end(Insert) );
insert( Input, At, ::boost::begin(Insert), ::boost::end(Insert) );
}
// erase helper ---------------------------------------------------//
@ -184,11 +184,11 @@ namespace boost {
{
if(From!=To)
{
::boost::algorithm::detail::replace( Input, From, To, ::boost::begin(Insert), ::boost::end(Insert) );
replace( Input, From, To, ::boost::begin(Insert), ::boost::end(Insert) );
}
else
{
::boost::algorithm::detail::insert( Input, From, ::boost::begin(Insert), ::boost::end(Insert) );
insert( Input, From, ::boost::begin(Insert), ::boost::end(Insert) );
}
}

View File

@ -20,6 +20,36 @@ namespace boost {
// trim iterator helper -----------------------------------------------//
// Search for first non matching character from the beginning of the sequence
template< typename ForwardIteratorT, typename PredicateT >
inline ForwardIteratorT trim_begin(
ForwardIteratorT InBegin,
ForwardIteratorT InEnd,
PredicateT IsSpace )
{
ForwardIteratorT It=InBegin;
for(; It!=InEnd; ++It )
{
if (!IsSpace(*It))
return It;
}
return It;
}
// Search for first non matching character from the end of the sequence
template< typename ForwardIteratorT, typename PredicateT >
inline ForwardIteratorT trim_end(
ForwardIteratorT InBegin,
ForwardIteratorT InEnd,
PredicateT IsSpace )
{
typedef BOOST_STRING_TYPENAME boost::detail::
iterator_traits<ForwardIteratorT>::iterator_category category;
return trim_end_iter_select( InBegin, InEnd, IsSpace, category() );
}
template< typename ForwardIteratorT, typename PredicateT >
inline ForwardIteratorT trim_end_iter_select(
ForwardIteratorT InBegin,
@ -56,36 +86,6 @@ namespace boost {
return InBegin;
}
// Search for first non matching character from the beginning of the sequence
template< typename ForwardIteratorT, typename PredicateT >
inline ForwardIteratorT trim_begin(
ForwardIteratorT InBegin,
ForwardIteratorT InEnd,
PredicateT IsSpace )
{
ForwardIteratorT It=InBegin;
for(; It!=InEnd; ++It )
{
if (!IsSpace(*It))
return It;
}
return It;
}
// Search for first non matching character from the end of the sequence
template< typename ForwardIteratorT, typename PredicateT >
inline ForwardIteratorT trim_end(
ForwardIteratorT InBegin,
ForwardIteratorT InEnd,
PredicateT IsSpace )
{
typedef BOOST_STRING_TYPENAME boost::detail::
iterator_traits<ForwardIteratorT>::iterator_category category;
return ::boost::algorithm::detail::trim_end_iter_select( InBegin, InEnd, IsSpace, category() );
}
} // namespace detail
} // namespace algorithm

View File

@ -54,11 +54,11 @@ namespace boost {
BOOST_STRING_TYPENAME
range_const_iterator<RangeT>::type>& SearchRange )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::range_finder(SearchRange),
::boost::algorithm::empty_formatter(Input) );
range_finder(SearchRange),
empty_formatter(Input) );
}
//! Erase range algorithm
@ -72,10 +72,10 @@ namespace boost {
BOOST_STRING_TYPENAME
range_const_iterator<SequenceT>::type>& SearchRange )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::range_finder(SearchRange),
::boost::algorithm::empty_formatter(Input) );
range_finder(SearchRange),
empty_formatter(Input) );
}
//! Erase range algorithm
@ -93,10 +93,10 @@ namespace boost {
BOOST_STRING_TYPENAME
range_iterator<SequenceT>::type>& SearchRange )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::range_finder(SearchRange),
::boost::algorithm::empty_formatter(Input) );
range_finder(SearchRange),
empty_formatter(Input) );
}
// erase_first --------------------------------------------------------//
@ -124,11 +124,11 @@ namespace boost {
const Range1T& Input,
const Range2T& Search )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::first_finder(Search),
::boost::algorithm::empty_formatter(Input) );
first_finder(Search),
empty_formatter(Input) );
}
//! Erase first algorithm
@ -140,10 +140,10 @@ namespace boost {
const SequenceT& Input,
const RangeT& Search )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::first_finder(Search),
::boost::algorithm::empty_formatter(Input) );
first_finder(Search),
empty_formatter(Input) );
}
//! Erase first algorithm
@ -159,10 +159,10 @@ namespace boost {
SequenceT& Input,
const RangeT& Search )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::first_finder(Search),
::boost::algorithm::empty_formatter(Input) );
first_finder(Search),
empty_formatter(Input) );
}
// erase_first ( case insensitive ) ------------------------------------//
@ -193,11 +193,11 @@ namespace boost {
const Range2T& Search,
const std::locale& Loc=std::locale() )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::first_finder(Search, is_iequal(Loc)),
::boost::algorithm::empty_formatter(Input) );
first_finder(Search, is_iequal(Loc)),
empty_formatter(Input) );
}
//! Erase first algorithm ( case insensitive )
@ -210,10 +210,10 @@ namespace boost {
const RangeT& Search,
const std::locale& Loc=std::locale() )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::first_finder(Search, is_iequal(Loc)),
::boost::algorithm::empty_formatter(Input) );
first_finder(Search, is_iequal(Loc)),
empty_formatter(Input) );
}
//! Erase first algorithm ( case insensitive )
@ -231,10 +231,10 @@ namespace boost {
const RangeT& Search,
const std::locale& Loc=std::locale() )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::first_finder(Search, is_iequal(Loc)),
::boost::algorithm::empty_formatter(Input) );
first_finder(Search, is_iequal(Loc)),
empty_formatter(Input) );
}
// erase_last --------------------------------------------------------//
@ -262,11 +262,11 @@ namespace boost {
const Range1T& Input,
const Range2T& Search )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::last_finder(Search),
::boost::algorithm::empty_formatter(Input) );
last_finder(Search),
empty_formatter(Input) );
}
//! Erase last algorithm
@ -278,10 +278,10 @@ namespace boost {
const SequenceT& Input,
const RangeT& Search )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::last_finder(Search),
::boost::algorithm::empty_formatter(Input) );
last_finder(Search),
empty_formatter(Input) );
}
//! Erase last algorithm
@ -297,10 +297,10 @@ namespace boost {
SequenceT& Input,
const RangeT& Search )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::last_finder(Search),
::boost::algorithm::empty_formatter(Input) );
last_finder(Search),
empty_formatter(Input) );
}
// erase_last ( case insensitive ) ------------------------------------//
@ -331,11 +331,11 @@ namespace boost {
const Range2T& Search,
const std::locale& Loc=std::locale() )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::last_finder(Search, is_iequal(Loc)),
::boost::algorithm::empty_formatter(Input) );
last_finder(Search, is_iequal(Loc)),
empty_formatter(Input) );
}
//! Erase last algorithm ( case insensitive )
@ -348,10 +348,10 @@ namespace boost {
const RangeT& Search,
const std::locale& Loc=std::locale() )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::last_finder(Search, is_iequal(Loc)),
::boost::algorithm::empty_formatter(Input) );
last_finder(Search, is_iequal(Loc)),
empty_formatter(Input) );
}
//! Erase last algorithm ( case insensitive )
@ -369,10 +369,10 @@ namespace boost {
const RangeT& Search,
const std::locale& Loc=std::locale() )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::last_finder(Search, is_iequal(Loc)),
::boost::algorithm::empty_formatter(Input) );
last_finder(Search, is_iequal(Loc)),
empty_formatter(Input) );
}
// erase_nth --------------------------------------------------------------------//
@ -404,11 +404,11 @@ namespace boost {
const Range2T& Search,
int Nth )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::nth_finder(Search, Nth),
::boost::algorithm::empty_formatter(Input) );
nth_finder(Search, Nth),
empty_formatter(Input) );
}
//! Erase nth algorithm
@ -421,10 +421,10 @@ namespace boost {
const RangeT& Search,
int Nth )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::nth_finder(Search, Nth),
::boost::algorithm::empty_formatter(Input) );
nth_finder(Search, Nth),
empty_formatter(Input) );
}
//! Erase nth algorithm
@ -443,10 +443,10 @@ namespace boost {
const RangeT& Search,
int Nth )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::nth_finder(Search, Nth),
::boost::algorithm::empty_formatter(Input) );
nth_finder(Search, Nth),
empty_formatter(Input) );
}
// erase_nth ( case insensitive ) ---------------------------------------------//
@ -480,11 +480,11 @@ namespace boost {
int Nth,
const std::locale& Loc=std::locale() )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
::boost::algorithm::empty_formatter(Input) );
nth_finder(Search, Nth, is_iequal(Loc)),
empty_formatter(Input) );
}
//! Erase nth algorithm
@ -498,9 +498,9 @@ namespace boost {
int Nth,
const std::locale& Loc=std::locale() )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
nth_finder(Search, Nth, is_iequal(Loc)),
empty_formatter(Input) );
}
@ -522,10 +522,10 @@ namespace boost {
int Nth,
const std::locale& Loc=std::locale() )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
::boost::algorithm::empty_formatter(Input) );
nth_finder(Search, Nth, is_iequal(Loc)),
empty_formatter(Input) );
}
@ -555,11 +555,11 @@ namespace boost {
const Range1T& Input,
const Range2T& Search )
{
return ::boost::algorithm::find_format_all_copy(
return find_format_all_copy(
Output,
Input,
::boost::algorithm::first_finder(Search),
::boost::algorithm::empty_formatter(Input) );
first_finder(Search),
empty_formatter(Input) );
}
//! Erase all algorithm
@ -571,10 +571,10 @@ namespace boost {
const SequenceT& Input,
const RangeT& Search )
{
return ::boost::algorithm::find_format_all_copy(
return find_format_all_copy(
Input,
::boost::algorithm::first_finder(Search),
::boost::algorithm::empty_formatter(Input) );
first_finder(Search),
empty_formatter(Input) );
}
//! Erase all algorithm
@ -590,10 +590,10 @@ namespace boost {
SequenceT& Input,
const RangeT& Search )
{
::boost::algorithm::find_format_all(
find_format_all(
Input,
::boost::algorithm::first_finder(Search),
::boost::algorithm::empty_formatter(Input) );
first_finder(Search),
empty_formatter(Input) );
}
// erase_all ( case insensitive ) ------------------------------------//
@ -624,11 +624,11 @@ namespace boost {
const Range2T& Search,
const std::locale& Loc=std::locale() )
{
return ::boost::algorithm::find_format_all_copy(
return find_format_all_copy(
Output,
Input,
::boost::algorithm::first_finder(Search, is_iequal(Loc)),
::boost::algorithm::empty_formatter(Input) );
first_finder(Search, is_iequal(Loc)),
empty_formatter(Input) );
}
//! Erase all algorithm ( case insensitive )
@ -641,10 +641,10 @@ namespace boost {
const RangeT& Search,
const std::locale& Loc=std::locale() )
{
return ::boost::algorithm::find_format_all_copy(
return find_format_all_copy(
Input,
::boost::algorithm::first_finder(Search, is_iequal(Loc)),
::boost::algorithm::empty_formatter(Input) );
first_finder(Search, is_iequal(Loc)),
empty_formatter(Input) );
}
//! Erase all algorithm ( case insensitive )
@ -662,10 +662,10 @@ namespace boost {
const RangeT& Search,
const std::locale& Loc=std::locale() )
{
::boost::algorithm::find_format_all(
find_format_all(
Input,
::boost::algorithm::first_finder(Search, is_iequal(Loc)),
::boost::algorithm::empty_formatter(Input) );
first_finder(Search, is_iequal(Loc)),
empty_formatter(Input) );
}
// erase_head --------------------------------------------------------------------//
@ -696,11 +696,11 @@ namespace boost {
const RangeT& Input,
int N )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::head_finder(N),
::boost::algorithm::empty_formatter( Input ) );
head_finder(N),
empty_formatter( Input ) );
}
//! Erase head algorithm
@ -712,10 +712,10 @@ namespace boost {
const SequenceT& Input,
int N )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::head_finder(N),
::boost::algorithm::empty_formatter( Input ) );
head_finder(N),
empty_formatter( Input ) );
}
//! Erase head algorithm
@ -734,10 +734,10 @@ namespace boost {
SequenceT& Input,
int N )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::head_finder(N),
::boost::algorithm::empty_formatter( Input ) );
head_finder(N),
empty_formatter( Input ) );
}
// erase_tail --------------------------------------------------------------------//
@ -752,7 +752,7 @@ namespace boost {
\param Output An output iterator to which the result will be copied
\param Input An input string
\param N Length of the tail.
\param N Length of the head.
For N>=0, at most N characters are extracted.
For N<0, size(Input)-|N| characters are extracted.
\return An output iterator pointing just after the last inserted character or
@ -768,11 +768,11 @@ namespace boost {
const RangeT& Input,
int N )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::tail_finder(N),
::boost::algorithm::empty_formatter( Input ) );
tail_finder(N),
empty_formatter( Input ) );
}
//! Erase tail algorithm
@ -784,10 +784,10 @@ namespace boost {
const SequenceT& Input,
int N )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::tail_finder(N),
::boost::algorithm::empty_formatter( Input ) );
tail_finder(N),
empty_formatter( Input ) );
}
//! Erase tail algorithm
@ -797,7 +797,7 @@ namespace boost {
considered to be the tail. The input sequence is modified in-place.
\param Input An input string
\param N Length of the tail
\param N Length of the head
For N>=0, at most N characters are extracted.
For N<0, size(Input)-|N| characters are extracted.
*/
@ -806,10 +806,10 @@ namespace boost {
SequenceT& Input,
int N )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::tail_finder(N),
::boost::algorithm::empty_formatter( Input ) );
tail_finder(N),
empty_formatter( Input ) );
}
} // namespace algorithm

View File

@ -53,7 +53,7 @@ namespace boost {
RangeT& Input,
const FinderT& Finder)
{
iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(as_literal(Input));
return Finder(::boost::begin(lit_input),::boost::end(lit_input));
}
@ -81,7 +81,7 @@ namespace boost {
Range1T& Input,
const Range2T& Search)
{
return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search));
return find(Input, first_finder(Search));
}
//! Find first algorithm ( case insensitive )
@ -108,7 +108,7 @@ namespace boost {
const Range2T& Search,
const std::locale& Loc=std::locale())
{
return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search,is_iequal(Loc)));
return find(Input, first_finder(Search,is_iequal(Loc)));
}
// find_last -----------------------------------------------//
@ -134,7 +134,7 @@ namespace boost {
Range1T& Input,
const Range2T& Search)
{
return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search));
return find(Input, last_finder(Search));
}
//! Find last algorithm ( case insensitive )
@ -161,7 +161,7 @@ namespace boost {
const Range2T& Search,
const std::locale& Loc=std::locale())
{
return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc)));
return find(Input, last_finder(Search, is_iequal(Loc)));
}
// find_nth ----------------------------------------------------------------------//
@ -189,7 +189,7 @@ namespace boost {
const Range2T& Search,
int Nth)
{
return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth));
return find(Input, nth_finder(Search,Nth));
}
//! Find n-th algorithm ( case insensitive ).
@ -220,7 +220,7 @@ namespace boost {
int Nth,
const std::locale& Loc=std::locale())
{
return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth,is_iequal(Loc)));
return find(Input, nth_finder(Search,Nth,is_iequal(Loc)));
}
// find_head ----------------------------------------------------------------------//
@ -250,14 +250,14 @@ namespace boost {
RangeT& Input,
int N)
{
return ::boost::algorithm::find(Input, ::boost::algorithm::head_finder(N));
return find(Input, head_finder(N));
}
// find_tail ----------------------------------------------------------------------//
//! Find tail algorithm
/*!
Get the tail of the input. Tail is a suffix of the string of the
Get the head of the input. Head is a suffix of the string of the
given size. If the input is shorter then required, whole input if considered
to be the tail.
@ -281,7 +281,7 @@ namespace boost {
RangeT& Input,
int N)
{
return ::boost::algorithm::find(Input, ::boost::algorithm::tail_finder(N));
return find(Input, tail_finder(N));
}
// find_token --------------------------------------------------------------------//
@ -311,7 +311,7 @@ namespace boost {
PredicateT Pred,
token_compress_mode_type eCompress=token_compress_off)
{
return ::boost::algorithm::find(Input, ::boost::algorithm::token_finder(Pred, eCompress));
return find(Input, token_finder(Pred, eCompress));
}
} // namespace algorithm

View File

@ -62,18 +62,15 @@ namespace boost {
FormatterT Formatter )
{
// Concept check
BOOST_CONCEPT_ASSERT((
FinderConcept<
FinderT,
BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
));
BOOST_CONCEPT_ASSERT((
function_requires<
FinderConcept<FinderT,
BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
function_requires<
FormatterConcept<
FormatterT,
FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
));
FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(as_literal(Input));
return detail::find_format_copy_impl(
Output,
@ -96,16 +93,13 @@ namespace boost {
FormatterT Formatter )
{
// Concept check
BOOST_CONCEPT_ASSERT((
FinderConcept<
FinderT,
BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
));
BOOST_CONCEPT_ASSERT((
function_requires<
FinderConcept<FinderT,
BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
function_requires<
FormatterConcept<
FormatterT,
FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
));
FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
return detail::find_format_copy_impl(
Input,
@ -132,16 +126,13 @@ namespace boost {
FormatterT Formatter)
{
// Concept check
BOOST_CONCEPT_ASSERT((
FinderConcept<
FinderT,
BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
));
BOOST_CONCEPT_ASSERT((
function_requires<
FinderConcept<FinderT,
BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
function_requires<
FormatterConcept<
FormatterT,
FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
));
FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
detail::find_format_impl(
Input,
@ -181,18 +172,15 @@ namespace boost {
FormatterT Formatter)
{
// Concept check
BOOST_CONCEPT_ASSERT((
FinderConcept<
FinderT,
BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
));
BOOST_CONCEPT_ASSERT((
function_requires<
FinderConcept<FinderT,
BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
function_requires<
FormatterConcept<
FormatterT,
FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
));
FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(as_literal(Input));
return detail::find_format_all_copy_impl(
Output,
@ -216,16 +204,13 @@ namespace boost {
FormatterT Formatter )
{
// Concept check
BOOST_CONCEPT_ASSERT((
FinderConcept<
FinderT,
BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
));
BOOST_CONCEPT_ASSERT((
function_requires<
FinderConcept<FinderT,
BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
function_requires<
FormatterConcept<
FormatterT,
FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
));
FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
return detail::find_format_all_copy_impl(
Input,
@ -254,16 +239,13 @@ namespace boost {
FormatterT Formatter )
{
// Concept check
BOOST_CONCEPT_ASSERT((
FinderConcept<
FinderT,
BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
));
BOOST_CONCEPT_ASSERT((
function_requires<
FinderConcept<FinderT,
BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
function_requires<
FormatterConcept<
FormatterT,
FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
));
FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> >();
detail::find_format_all_impl(
Input,

View File

@ -113,8 +113,8 @@ namespace boost {
FinderT Finder ) :
detail::find_iterator_base<IteratorT>(Finder,0)
{
iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col));
m_Match=::boost::make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col));
iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(as_literal(Col));
m_Match=make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col));
m_End=::boost::end(lit_col);
increment();
@ -240,7 +240,7 @@ namespace boost {
m_Match(Other.m_Match),
m_Next(Other.m_Next),
m_End(Other.m_End),
m_bEof(Other.m_bEof)
m_bEof(false)
{}
//! Constructor
@ -259,11 +259,7 @@ namespace boost {
m_End(End),
m_bEof(false)
{
// force the correct behavior for empty sequences and yield at least one token
if(Begin!=End)
{
increment();
}
increment();
}
//! Constructor
/*!
@ -277,16 +273,12 @@ namespace boost {
detail::find_iterator_base<IteratorT>(Finder,0),
m_bEof(false)
{
iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col));
iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(as_literal(Col));
m_Match=make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col));
m_Next=::boost::begin(lit_col);
m_End=::boost::end(lit_col);
// force the correct behavior for empty sequences and yield at least one token
if(m_Next!=m_End)
{
increment();
}
increment();
}

View File

@ -56,7 +56,7 @@ namespace boost {
detail::first_finderF<
BOOST_STRING_TYPENAME
range_const_iterator<RangeT>::type,
is_equal>( ::boost::as_literal(Search), is_equal() ) ;
is_equal>( as_literal(Search), is_equal() ) ;
}
//! "First" finder
@ -74,7 +74,7 @@ namespace boost {
detail::first_finderF<
BOOST_STRING_TYPENAME
range_const_iterator<RangeT>::type,
PredicateT>( ::boost::as_literal(Search), Comp );
PredicateT>( as_literal(Search), Comp );
}
//! "Last" finder
@ -97,7 +97,7 @@ namespace boost {
detail::last_finderF<
BOOST_STRING_TYPENAME
range_const_iterator<RangeT>::type,
is_equal>( ::boost::as_literal(Search), is_equal() );
is_equal>( as_literal(Search), is_equal() );
}
//! "Last" finder
/*!
@ -113,7 +113,7 @@ namespace boost {
detail::last_finderF<
BOOST_STRING_TYPENAME
range_const_iterator<RangeT>::type,
PredicateT>( ::boost::as_literal(Search), Comp ) ;
PredicateT>( as_literal(Search), Comp ) ;
}
//! "Nth" finder
@ -139,7 +139,7 @@ namespace boost {
detail::nth_finderF<
BOOST_STRING_TYPENAME
range_const_iterator<RangeT>::type,
is_equal>( ::boost::as_literal(Search), Nth, is_equal() ) ;
is_equal>( as_literal(Search), Nth, is_equal() ) ;
}
//! "Nth" finder
/*!
@ -158,7 +158,7 @@ namespace boost {
detail::nth_finderF<
BOOST_STRING_TYPENAME
range_const_iterator<RangeT>::type,
PredicateT>( ::boost::as_literal(Search), Nth, Comp );
PredicateT>( as_literal(Search), Nth, Comp );
}
//! "Head" finder

View File

@ -50,7 +50,7 @@ namespace boost {
{
return detail::const_formatF<
iterator_range<
BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >(::boost::as_literal(Format));
BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >(as_literal(Format));
}
//! Identity formatter

View File

@ -74,13 +74,11 @@ namespace boost {
RangeT& Input,
FinderT Finder )
{
BOOST_CONCEPT_ASSERT((
FinderConcept<
FinderT,
BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
));
function_requires<
FinderConcept<FinderT,
BOOST_STRING_TYPENAME range_iterator<RangeT>::type> >();
iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(as_literal(Input));
typedef BOOST_STRING_TYPENAME
range_iterator<RangeT>::type input_iterator_type;
@ -96,12 +94,12 @@ namespace boost {
transform_iter_type;
transform_iter_type itBegin=
::boost::make_transform_iterator(
make_transform_iterator(
find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
copy_range_type());
transform_iter_type itEnd=
::boost::make_transform_iterator(
make_transform_iterator(
find_iterator_type(),
copy_range_type());
@ -145,12 +143,11 @@ namespace boost {
RangeT& Input,
FinderT Finder )
{
BOOST_CONCEPT_ASSERT((
function_requires<
FinderConcept<FinderT,
BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
));
BOOST_STRING_TYPENAME range_iterator<RangeT>::type> >();
iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(as_literal(Input));
typedef BOOST_STRING_TYPENAME
range_iterator<RangeT>::type input_iterator_type;
@ -166,12 +163,12 @@ namespace boost {
transform_iter_type;
transform_iter_type itBegin=
::boost::make_transform_iterator(
make_transform_iterator(
find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
copy_range_type() );
transform_iter_type itEnd=
::boost::make_transform_iterator(
make_transform_iterator(
find_iterator_type(),
copy_range_type() );

View File

@ -68,7 +68,7 @@ namespace boost {
for(;itBegin!=itEnd; ++itBegin)
{
// Add separator
detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
detail::insert(Result, ::boost::end(Result), as_literal(Separator));
// Add element
detail::insert(Result, ::boost::end(Result), *itBegin);
}
@ -123,7 +123,7 @@ namespace boost {
if(Pred(*itBegin))
{
// Add separator
detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
detail::insert(Result, ::boost::end(Result), as_literal(Separator));
// Add element
detail::insert(Result, ::boost::end(Result), *itBegin);
}

View File

@ -59,8 +59,8 @@ namespace boost {
const Range2T& Test,
PredicateT Comp)
{
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(as_literal(Input));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(as_literal(Test));
typedef BOOST_STRING_TYPENAME
range_const_iterator<Range1T>::type Iterator1T;
@ -92,7 +92,7 @@ namespace boost {
const Range1T& Input,
const Range2T& Test)
{
return ::boost::algorithm::starts_with(Input, Test, is_equal());
return starts_with(Input, Test, is_equal());
}
//! 'Starts with' predicate ( case insensitive )
@ -114,7 +114,7 @@ namespace boost {
const Range2T& Test,
const std::locale& Loc=std::locale())
{
return ::boost::algorithm::starts_with(Input, Test, is_iequal(Loc));
return starts_with(Input, Test, is_iequal(Loc));
}
@ -141,8 +141,8 @@ namespace boost {
const Range2T& Test,
PredicateT Comp)
{
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(as_literal(Input));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(as_literal(Test));
typedef BOOST_STRING_TYPENAME
range_const_iterator<Range1T>::type Iterator1T;
@ -169,7 +169,7 @@ namespace boost {
const Range1T& Input,
const Range2T& Test)
{
return ::boost::algorithm::ends_with(Input, Test, is_equal());
return ends_with(Input, Test, is_equal());
}
//! 'Ends with' predicate ( case insensitive )
@ -191,7 +191,7 @@ namespace boost {
const Range2T& Test,
const std::locale& Loc=std::locale())
{
return ::boost::algorithm::ends_with(Input, Test, is_iequal(Loc));
return ends_with(Input, Test, is_iequal(Loc));
}
// contains predicate -----------------------------------------------//
@ -215,17 +215,17 @@ namespace boost {
const Range2T& Test,
PredicateT Comp)
{
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(as_literal(Input));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(as_literal(Test));
if (::boost::empty(lit_test))
if (empty(lit_test))
{
// Empty range is contained always
return true;
}
// Use the temporary variable to make VACPP happy
bool bResult=(::boost::algorithm::first_finder(lit_test,Comp)(::boost::begin(lit_input), ::boost::end(lit_input)));
bool bResult=(first_finder(lit_test,Comp)(::boost::begin(lit_input), ::boost::end(lit_input)));
return bResult;
}
@ -238,7 +238,7 @@ namespace boost {
const Range1T& Input,
const Range2T& Test)
{
return ::boost::algorithm::contains(Input, Test, is_equal());
return contains(Input, Test, is_equal());
}
//! 'Contains' predicate ( case insensitive )
@ -259,7 +259,7 @@ namespace boost {
const Range2T& Test,
const std::locale& Loc=std::locale())
{
return ::boost::algorithm::contains(Input, Test, is_iequal(Loc));
return contains(Input, Test, is_iequal(Loc));
}
// equals predicate -----------------------------------------------//
@ -286,8 +286,8 @@ namespace boost {
const Range2T& Test,
PredicateT Comp)
{
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(as_literal(Input));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(as_literal(Test));
typedef BOOST_STRING_TYPENAME
range_const_iterator<Range1T>::type Iterator1T;
@ -319,7 +319,7 @@ namespace boost {
const Range1T& Input,
const Range2T& Test)
{
return ::boost::algorithm::equals(Input, Test, is_equal());
return equals(Input, Test, is_equal());
}
//! 'Equals' predicate ( case insensitive )
@ -343,7 +343,7 @@ namespace boost {
const Range2T& Test,
const std::locale& Loc=std::locale())
{
return ::boost::algorithm::equals(Input, Test, is_iequal(Loc));
return equals(Input, Test, is_iequal(Loc));
}
// lexicographical_compare predicate -----------------------------//
@ -372,8 +372,8 @@ namespace boost {
const Range2T& Arg2,
PredicateT Pred)
{
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_arg1(::boost::as_literal(Arg1));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_arg2(::boost::as_literal(Arg2));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_arg1(as_literal(Arg1));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_arg2(as_literal(Arg2));
return std::lexicographical_compare(
::boost::begin(lit_arg1),
@ -392,7 +392,7 @@ namespace boost {
const Range1T& Arg1,
const Range2T& Arg2)
{
return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_less());
return lexicographical_compare(Arg1, Arg2, is_less());
}
//! Lexicographical compare predicate (case-insensitive)
@ -417,7 +417,7 @@ namespace boost {
const Range2T& Arg2,
const std::locale& Loc=std::locale())
{
return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_iless(Loc));
return lexicographical_compare(Arg1, Arg2, is_iless(Loc));
}
@ -439,7 +439,7 @@ namespace boost {
const RangeT& Input,
PredicateT Pred)
{
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(as_literal(Input));
typedef BOOST_STRING_TYPENAME
range_const_iterator<RangeT>::type Iterator1T;

View File

@ -60,9 +60,9 @@ namespace boost {
const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default )
{
iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(as_literal(Input));
return ::boost::algorithm::regex_finder(Rx,Flags)(
return regex_finder(Rx,Flags)(
::boost::begin(lit_input), ::boost::end(lit_input) );
}
@ -98,11 +98,11 @@ namespace boost {
const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
match_flag_type Flags=match_default | format_default )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::regex_finder( Rx, Flags ),
::boost::algorithm::regex_formatter( Format, Flags ) );
regex_finder( Rx, Flags ),
regex_formatter( Format, Flags ) );
}
//! Replace regex algorithm
@ -120,10 +120,10 @@ namespace boost {
const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
match_flag_type Flags=match_default | format_default )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::regex_finder( Rx, Flags ),
::boost::algorithm::regex_formatter( Format, Flags ) );
regex_finder( Rx, Flags ),
regex_formatter( Format, Flags ) );
}
//! Replace regex algorithm
@ -147,10 +147,10 @@ namespace boost {
const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
match_flag_type Flags=match_default | format_default )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::regex_finder( Rx, Flags ),
::boost::algorithm::regex_formatter( Format, Flags ) );
regex_finder( Rx, Flags ),
regex_formatter( Format, Flags ) );
}
// replace_all_regex --------------------------------------------------------------------//
@ -184,11 +184,11 @@ namespace boost {
const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
match_flag_type Flags=match_default | format_default )
{
return ::boost::algorithm::find_format_all_copy(
return find_format_all_copy(
Output,
Input,
::boost::algorithm::regex_finder( Rx, Flags ),
::boost::algorithm::regex_formatter( Format, Flags ) );
regex_finder( Rx, Flags ),
regex_formatter( Format, Flags ) );
}
//! Replace all regex algorithm
@ -206,10 +206,10 @@ namespace boost {
const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
match_flag_type Flags=match_default | format_default )
{
return ::boost::algorithm::find_format_all_copy(
return find_format_all_copy(
Input,
::boost::algorithm::regex_finder( Rx, Flags ),
::boost::algorithm::regex_formatter( Format, Flags ) );
regex_finder( Rx, Flags ),
regex_formatter( Format, Flags ) );
}
//! Replace all regex algorithm
@ -233,10 +233,10 @@ namespace boost {
const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
match_flag_type Flags=match_default | format_default )
{
::boost::algorithm::find_format_all(
find_format_all(
Input,
::boost::algorithm::regex_finder( Rx, Flags ),
::boost::algorithm::regex_formatter( Format, Flags ) );
regex_finder( Rx, Flags ),
regex_formatter( Format, Flags ) );
}
// erase_regex --------------------------------------------------------------------//
@ -267,11 +267,11 @@ namespace boost {
const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::regex_finder( Rx, Flags ),
::boost::algorithm::empty_formatter( Input ) );
regex_finder( Rx, Flags ),
empty_formatter( Input ) );
}
//! Erase regex algorithm
@ -287,10 +287,10 @@ namespace boost {
const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::regex_finder( Rx, Flags ),
::boost::algorithm::empty_formatter( Input ) );
regex_finder( Rx, Flags ),
empty_formatter( Input ) );
}
//! Erase regex algorithm
@ -311,10 +311,10 @@ namespace boost {
const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::regex_finder( Rx, Flags ),
::boost::algorithm::empty_formatter( Input ) );
regex_finder( Rx, Flags ),
empty_formatter( Input ) );
}
// erase_all_regex --------------------------------------------------------------------//
@ -346,11 +346,11 @@ namespace boost {
const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default )
{
return ::boost::algorithm::find_format_all_copy(
return find_format_all_copy(
Output,
Input,
::boost::algorithm::regex_finder( Rx, Flags ),
::boost::algorithm::empty_formatter( Input ) );
regex_finder( Rx, Flags ),
empty_formatter( Input ) );
}
//! Erase all regex algorithm
@ -366,10 +366,10 @@ namespace boost {
const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default )
{
return ::boost::algorithm::find_format_all_copy(
return find_format_all_copy(
Input,
::boost::algorithm::regex_finder( Rx, Flags ),
::boost::algorithm::empty_formatter( Input ) );
regex_finder( Rx, Flags ),
empty_formatter( Input ) );
}
//! Erase all regex algorithm
@ -390,10 +390,10 @@ namespace boost {
const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default )
{
::boost::algorithm::find_format_all(
find_format_all(
Input,
::boost::algorithm::regex_finder( Rx, Flags ),
::boost::algorithm::empty_formatter( Input ) );
regex_finder( Rx, Flags ),
empty_formatter( Input ) );
}
// find_all_regex ------------------------------------------------------------------//
@ -431,10 +431,10 @@ namespace boost {
const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default )
{
return ::boost::algorithm::iter_find(
return iter_find(
Result,
Input,
::boost::algorithm::regex_finder(Rx,Flags) );
regex_finder(Rx,Flags) );
}
// split_regex ------------------------------------------------------------------//
@ -472,10 +472,10 @@ namespace boost {
const basic_regex<CharT, RegexTraitsT>& Rx,
match_flag_type Flags=match_default )
{
return ::boost::algorithm::iter_split(
return iter_split(
Result,
Input,
::boost::algorithm::regex_finder(Rx,Flags) );
regex_finder(Rx,Flags) );
}
// join_if ------------------------------------------------------------------//
@ -525,7 +525,7 @@ namespace boost {
// Roll to the first element that will be added
while(
itBegin!=itEnd &&
!::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) ++itBegin;
!regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) ++itBegin;
// Add this element
if(itBegin!=itEnd)
@ -536,10 +536,10 @@ namespace boost {
for(;itBegin!=itEnd; ++itBegin)
{
if(::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags))
if(regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags))
{
// Add separator
detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
detail::insert(Result, ::boost::end(Result), as_literal(Separator));
// Add element
detail::insert(Result, ::boost::end(Result), *itBegin);
}
@ -593,7 +593,7 @@ namespace boost {
// Roll to the first element that will be added
while(
itBegin!=itEnd &&
!::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) ++itBegin;
!regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) ++itBegin;
// Add this element
if(itBegin!=itEnd)
@ -604,10 +604,10 @@ namespace boost {
for(;itBegin!=itEnd; ++itBegin)
{
if(::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags))
if(regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags))
{
// Add separator
detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
detail::insert(Result, ::boost::end(Result), as_literal(Separator));
// Add element
detail::insert(Result, ::boost::end(Result), *itBegin);
}

View File

@ -61,11 +61,11 @@ namespace boost {
range_const_iterator<Range1T>::type>& SearchRange,
const Range2T& Format)
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::range_finder(SearchRange),
::boost::algorithm::const_formatter(Format));
range_finder(SearchRange),
const_formatter(Format));
}
//! Replace range algorithm
@ -80,10 +80,10 @@ namespace boost {
range_const_iterator<SequenceT>::type>& SearchRange,
const RangeT& Format)
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::range_finder(SearchRange),
::boost::algorithm::const_formatter(Format));
range_finder(SearchRange),
const_formatter(Format));
}
//! Replace range algorithm
@ -103,10 +103,10 @@ namespace boost {
range_iterator<SequenceT>::type>& SearchRange,
const RangeT& Format)
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::range_finder(SearchRange),
::boost::algorithm::const_formatter(Format));
range_finder(SearchRange),
const_formatter(Format));
}
// replace_first --------------------------------------------------------------------//
@ -138,11 +138,11 @@ namespace boost {
const Range2T& Search,
const Range3T& Format)
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::first_finder(Search),
::boost::algorithm::const_formatter(Format) );
first_finder(Search),
const_formatter(Format) );
}
//! Replace first algorithm
@ -155,10 +155,10 @@ namespace boost {
const Range1T& Search,
const Range2T& Format )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::first_finder(Search),
::boost::algorithm::const_formatter(Format) );
first_finder(Search),
const_formatter(Format) );
}
//! Replace first algorithm
@ -176,10 +176,10 @@ namespace boost {
const Range1T& Search,
const Range2T& Format )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::first_finder(Search),
::boost::algorithm::const_formatter(Format) );
first_finder(Search),
const_formatter(Format) );
}
// replace_first ( case insensitive ) ---------------------------------------------//
@ -214,11 +214,11 @@ namespace boost {
const Range3T& Format,
const std::locale& Loc=std::locale() )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::first_finder(Search, is_iequal(Loc)),
::boost::algorithm::const_formatter(Format) );
first_finder(Search, is_iequal(Loc)),
const_formatter(Format) );
}
//! Replace first algorithm ( case insensitive )
@ -232,10 +232,10 @@ namespace boost {
const Range1T& Format,
const std::locale& Loc=std::locale() )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::first_finder(Search, is_iequal(Loc)),
::boost::algorithm::const_formatter(Format) );
first_finder(Search, is_iequal(Loc)),
const_formatter(Format) );
}
//! Replace first algorithm ( case insensitive )
@ -256,10 +256,10 @@ namespace boost {
const Range2T& Format,
const std::locale& Loc=std::locale() )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::first_finder(Search, is_iequal(Loc)),
::boost::algorithm::const_formatter(Format) );
first_finder(Search, is_iequal(Loc)),
const_formatter(Format) );
}
// replace_last --------------------------------------------------------------------//
@ -291,11 +291,11 @@ namespace boost {
const Range2T& Search,
const Range3T& Format )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::last_finder(Search),
::boost::algorithm::const_formatter(Format) );
last_finder(Search),
const_formatter(Format) );
}
//! Replace last algorithm
@ -308,10 +308,10 @@ namespace boost {
const Range1T& Search,
const Range2T& Format )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::last_finder(Search),
::boost::algorithm::const_formatter(Format) );
last_finder(Search),
const_formatter(Format) );
}
//! Replace last algorithm
@ -329,10 +329,10 @@ namespace boost {
const Range1T& Search,
const Range2T& Format )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::last_finder(Search),
::boost::algorithm::const_formatter(Format) );
last_finder(Search),
const_formatter(Format) );
}
// replace_last ( case insensitive ) -----------------------------------------------//
@ -367,11 +367,11 @@ namespace boost {
const Range3T& Format,
const std::locale& Loc=std::locale() )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::last_finder(Search, is_iequal(Loc)),
::boost::algorithm::const_formatter(Format) );
last_finder(Search, is_iequal(Loc)),
const_formatter(Format) );
}
//! Replace last algorithm ( case insensitive )
@ -385,10 +385,10 @@ namespace boost {
const Range2T& Format,
const std::locale& Loc=std::locale() )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::last_finder(Search, is_iequal(Loc)),
::boost::algorithm::const_formatter(Format) );
last_finder(Search, is_iequal(Loc)),
const_formatter(Format) );
}
//! Replace last algorithm ( case insensitive )
@ -410,10 +410,10 @@ namespace boost {
const Range2T& Format,
const std::locale& Loc=std::locale() )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::last_finder(Search, is_iequal(Loc)),
::boost::algorithm::const_formatter(Format) );
last_finder(Search, is_iequal(Loc)),
const_formatter(Format) );
}
// replace_nth --------------------------------------------------------------------//
@ -448,11 +448,11 @@ namespace boost {
int Nth,
const Range3T& Format )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::nth_finder(Search, Nth),
::boost::algorithm::const_formatter(Format) );
nth_finder(Search, Nth),
const_formatter(Format) );
}
//! Replace nth algorithm
@ -466,10 +466,10 @@ namespace boost {
int Nth,
const Range2T& Format )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::nth_finder(Search, Nth),
::boost::algorithm::const_formatter(Format) );
nth_finder(Search, Nth),
const_formatter(Format) );
}
//! Replace nth algorithm
@ -490,10 +490,10 @@ namespace boost {
int Nth,
const Range2T& Format )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::nth_finder(Search, Nth),
::boost::algorithm::const_formatter(Format) );
nth_finder(Search, Nth),
const_formatter(Format) );
}
// replace_nth ( case insensitive ) -----------------------------------------------//
@ -531,11 +531,11 @@ namespace boost {
const Range3T& Format,
const std::locale& Loc=std::locale() )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc) ),
::boost::algorithm::const_formatter(Format) );
nth_finder(Search, Nth, is_iequal(Loc) ),
const_formatter(Format) );
}
//! Replace nth algorithm ( case insensitive )
@ -550,10 +550,10 @@ namespace boost {
const Range2T& Format,
const std::locale& Loc=std::locale() )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
::boost::algorithm::const_formatter(Format) );
nth_finder(Search, Nth, is_iequal(Loc)),
const_formatter(Format) );
}
//! Replace nth algorithm ( case insensitive )
@ -577,10 +577,10 @@ namespace boost {
const Range2T& Format,
const std::locale& Loc=std::locale() )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
::boost::algorithm::const_formatter(Format) );
nth_finder(Search, Nth, is_iequal(Loc)),
const_formatter(Format) );
}
// replace_all --------------------------------------------------------------------//
@ -612,11 +612,11 @@ namespace boost {
const Range2T& Search,
const Range3T& Format )
{
return ::boost::algorithm::find_format_all_copy(
return find_format_all_copy(
Output,
Input,
::boost::algorithm::first_finder(Search),
::boost::algorithm::const_formatter(Format) );
first_finder(Search),
const_formatter(Format) );
}
//! Replace all algorithm
@ -629,10 +629,10 @@ namespace boost {
const Range1T& Search,
const Range2T& Format )
{
return ::boost::algorithm::find_format_all_copy(
return find_format_all_copy(
Input,
::boost::algorithm::first_finder(Search),
::boost::algorithm::const_formatter(Format) );
first_finder(Search),
const_formatter(Format) );
}
//! Replace all algorithm
@ -651,10 +651,10 @@ namespace boost {
const Range1T& Search,
const Range2T& Format )
{
::boost::algorithm::find_format_all(
find_format_all(
Input,
::boost::algorithm::first_finder(Search),
::boost::algorithm::const_formatter(Format) );
first_finder(Search),
const_formatter(Format) );
}
// replace_all ( case insensitive ) -----------------------------------------------//
@ -689,11 +689,11 @@ namespace boost {
const Range3T& Format,
const std::locale& Loc=std::locale() )
{
return ::boost::algorithm::find_format_all_copy(
return find_format_all_copy(
Output,
Input,
::boost::algorithm::first_finder(Search, is_iequal(Loc)),
::boost::algorithm::const_formatter(Format) );
first_finder(Search, is_iequal(Loc)),
const_formatter(Format) );
}
//! Replace all algorithm ( case insensitive )
@ -707,10 +707,10 @@ namespace boost {
const Range2T& Format,
const std::locale& Loc=std::locale() )
{
return ::boost::algorithm::find_format_all_copy(
return find_format_all_copy(
Input,
::boost::algorithm::first_finder(Search, is_iequal(Loc)),
::boost::algorithm::const_formatter(Format) );
first_finder(Search, is_iequal(Loc)),
const_formatter(Format) );
}
//! Replace all algorithm ( case insensitive )
@ -731,10 +731,10 @@ namespace boost {
const Range2T& Format,
const std::locale& Loc=std::locale() )
{
::boost::algorithm::find_format_all(
find_format_all(
Input,
::boost::algorithm::first_finder(Search, is_iequal(Loc)),
::boost::algorithm::const_formatter(Format) );
first_finder(Search, is_iequal(Loc)),
const_formatter(Format) );
}
// replace_head --------------------------------------------------------------------//
@ -769,11 +769,11 @@ namespace boost {
int N,
const Range2T& Format )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::head_finder(N),
::boost::algorithm::const_formatter(Format) );
head_finder(N),
const_formatter(Format) );
}
//! Replace head algorithm
@ -786,10 +786,10 @@ namespace boost {
int N,
const RangeT& Format )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::head_finder(N),
::boost::algorithm::const_formatter(Format) );
head_finder(N),
const_formatter(Format) );
}
//! Replace head algorithm
@ -811,10 +811,10 @@ namespace boost {
int N,
const RangeT& Format )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::head_finder(N),
::boost::algorithm::const_formatter(Format) );
head_finder(N),
const_formatter(Format) );
}
// replace_tail --------------------------------------------------------------------//
@ -849,11 +849,11 @@ namespace boost {
int N,
const Range2T& Format )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Output,
Input,
::boost::algorithm::tail_finder(N),
::boost::algorithm::const_formatter(Format) );
tail_finder(N),
const_formatter(Format) );
}
//! Replace tail algorithm
@ -866,10 +866,10 @@ namespace boost {
int N,
const RangeT& Format )
{
return ::boost::algorithm::find_format_copy(
return find_format_copy(
Input,
::boost::algorithm::tail_finder(N),
::boost::algorithm::const_formatter(Format) );
tail_finder(N),
const_formatter(Format) );
}
//! Replace tail algorithm
@ -891,10 +891,10 @@ namespace boost {
int N,
const RangeT& Format )
{
::boost::algorithm::find_format(
find_format(
Input,
::boost::algorithm::tail_finder(N),
::boost::algorithm::const_formatter(Format) );
tail_finder(N),
const_formatter(Format) );
}
} // namespace algorithm

View File

@ -64,10 +64,10 @@ namespace boost {
Range1T& Input,
const Range2T& Search)
{
return ::boost::algorithm::iter_find(
return iter_find(
Result,
Input,
::boost::algorithm::first_finder(Search) );
first_finder(Search) );
}
//! Find all algorithm ( case insensitive )
@ -100,10 +100,10 @@ namespace boost {
const Range2T& Search,
const std::locale& Loc=std::locale() )
{
return ::boost::algorithm::iter_find(
return iter_find(
Result,
Input,
::boost::algorithm::first_finder(Search, is_iequal(Loc) ) );
first_finder(Search, is_iequal(Loc) ) );
}
@ -143,10 +143,10 @@ namespace boost {
PredicateT Pred,
token_compress_mode_type eCompress=token_compress_off )
{
return ::boost::algorithm::iter_split(
return iter_split(
Result,
Input,
::boost::algorithm::token_finder( Pred, eCompress ) );
token_finder( Pred, eCompress ) );
}
} // namespace algorithm

View File

@ -63,7 +63,7 @@ namespace boost {
const RangeT& Input,
PredicateT IsSpace)
{
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(as_literal(Input));
std::copy(
::boost::algorithm::detail::trim_begin(
@ -106,7 +106,7 @@ namespace boost {
inline SequenceT trim_left_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
{
return
::boost::algorithm::trim_left_copy_if(
trim_left_copy_if(
Input,
is_space(Loc));
}
@ -142,7 +142,7 @@ namespace boost {
template<typename SequenceT>
inline void trim_left(SequenceT& Input, const std::locale& Loc=std::locale())
{
::boost::algorithm::trim_left_if(
trim_left_if(
Input,
is_space(Loc));
}
@ -171,7 +171,7 @@ namespace boost {
const RangeT& Input,
PredicateT IsSpace )
{
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(as_literal(Input));
std::copy(
::boost::begin(lit_range),
@ -215,7 +215,7 @@ namespace boost {
inline SequenceT trim_right_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
{
return
::boost::algorithm::trim_right_copy_if(
trim_right_copy_if(
Input,
is_space(Loc));
}
@ -254,7 +254,7 @@ namespace boost {
template<typename SequenceT>
inline void trim_right(SequenceT& Input, const std::locale& Loc=std::locale())
{
::boost::algorithm::trim_right_if(
trim_right_if(
Input,
is_space(Loc) );
}
@ -283,7 +283,7 @@ namespace boost {
const RangeT& Input,
PredicateT IsSpace)
{
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));
iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(as_literal(Input));
BOOST_STRING_TYPENAME
range_const_iterator<RangeT>::type TrimEnd=
@ -340,7 +340,7 @@ namespace boost {
inline SequenceT trim_copy( const SequenceT& Input, const std::locale& Loc=std::locale() )
{
return
::boost::algorithm::trim_copy_if(
trim_copy_if(
Input,
is_space(Loc) );
}
@ -357,8 +357,8 @@ namespace boost {
template<typename SequenceT, typename PredicateT>
inline void trim_if(SequenceT& Input, PredicateT IsSpace)
{
::boost::algorithm::trim_right_if( Input, IsSpace );
::boost::algorithm::trim_left_if( Input, IsSpace );
trim_right_if( Input, IsSpace );
trim_left_if( Input, IsSpace );
}
//! Trim
@ -372,7 +372,7 @@ namespace boost {
template<typename SequenceT>
inline void trim(SequenceT& Input, const std::locale& Loc=std::locale())
{
::boost::algorithm::trim_if(
trim_if(
Input,
is_space( Loc ) );
}

View File

@ -92,11 +92,11 @@ Synopsis of <tt>&lt;boost/algorithm/minmax.hpp></tt></h3>
namespace boost {
template &lt;class T>
tuple&lt;T const&amp;, T const&amp;>
tuple&lt;T const&amp;, T const&amp;> >
minmax(const T&amp; a, const T&amp; b);
template &lt;class T, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
tuple&lt;T const&amp;, T const&amp;>
tuple&lt;T const&amp;, T const&amp;> >
minmax(const T&amp; a, const T&amp; b, BinaryPredicate comp);
}
@ -158,9 +158,9 @@ identical to
that they return the last instance of the largest element (and not the
first, as <tt>first_min_element</tt> and <tt>last_max_element</tt> would).
<p>The family of algorithms comprising <tt>first_min_first_max_element</tt>,
<tt>first_min_last_max_element</tt>,
<tt>last_min_first_max_element</tt>,
and <tt>last_min_last_max_element</tt> can be described generically as
<tt>first_min_first_max_element</tt>,
<tt>first_min_first_max_element</tt>,
and <tt>first_min_first_max_element</tt> can be described generically as
follows (using <i><tt>which</tt></i> and
<i><tt>what</tt></i> for <tt>first</tt>
or <tt>last</tt>): <tt><i>which</i>_min_<i>what</i>_max_element</tt> finds
@ -243,7 +243,7 @@ range
<a name="complexity">
<h3>
Complexity</h3>
<a NAME="Complexity"></a>Complexity</h3>
Minmax performs a single comparison and is otherwise of constant complexity.
The use of <tt>boost::tuple&lt;T const&amp;></tt> prevents copy
constructors in case the arguments are passed by reference.
@ -438,7 +438,7 @@ comparisons).</p>
slower than
<tt>first_min_element</tt> alone, still much less than <tt>first_min_element</tt>
and
<tt>last_max_element</tt> called separately. <a href="#Note2">[2]</a>
<tt>last_max_element</tt> called separately. <a href="#Performance">[2]</a>
<h4><b>Why algorithms and not accumulators?</b></h4>
<p>The minmax algorithms are useful in computing the extent of a range.

View File

@ -0,0 +1,8 @@
#-------------------------------------------------------------------------
#-- Needed include directories for the tests
boost_test_add_dependent_includes("utility;detail;config;test;mpl;bind;type_traits;static_assert;preprocessor;array;iterator;timer;tuple;range")
#-------------------------------------------------------------------------
boost_test_run(minmax_element_test)
boost_test_run(minmax_test)

View File

@ -54,23 +54,23 @@ void test(BOOST_EXPLICIT_TEMPLATE_TYPE(Value))
less_count<Value> lc(counter);
// Test functionality
tuple<Value const&, Value const&> result1 = boost::minmax(zero, one);
tuple<Value const&, Value const&> result1 = minmax(zero, one);
BOOST_CHECK_EQUAL( get<0>(result1), zero );
BOOST_CHECK_EQUAL( get<1>(result1), one );
tuple<Value const&, Value const&> result2 = boost::minmax(one, zero);
tuple<Value const&, Value const&> result2 = minmax(one, zero);
BOOST_CHECK_EQUAL( get<0>(result2), zero );
BOOST_CHECK_EQUAL( get<1>(result2), one );
// Test functionality and number of comparisons
lc.reset();
tuple<Value const&, Value const&> result3 = boost::minmax(zero, one, lc );
tuple<Value const&, Value const&> result3 = minmax(zero, one, lc );
BOOST_CHECK_EQUAL( get<0>(result3), zero );
BOOST_CHECK_EQUAL( get<1>(result3), one );
BOOST_CHECK_EQUAL( counter, 1 );
lc.reset();
tuple<Value const&, Value const&> result4 = boost::minmax(one, zero, lc );
tuple<Value const&, Value const&> result4 = minmax(one, zero, lc );
BOOST_CHECK_EQUAL( get<0>(result4), zero );
BOOST_CHECK_EQUAL( get<1>(result4), one );
BOOST_CHECK_EQUAL( counter, 1);

1
module.cmake Normal file
View File

@ -0,0 +1 @@
boost_module(algorithm DEPENDS regex concept_check)

View File

@ -10,11 +10,7 @@
import toolset ;
toolset.using doxygen ;
boostbook string_algo : string_algo.xml autodoc
:
<xsl:param>boost.root=../../../../..
<format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
;
boostbook string_algo : string_algo.xml autodoc ;
doxygen autodoc
:

View File

@ -25,7 +25,7 @@
</para>
<para>
<emphasis role="bold">Definition:</emphasis> A string is a
<ulink url="../../libs/range/index.html">range</ulink> of characters accessible in sequential
<ulink url="../../libs/range/doc/range.html">range</ulink> of characters accessible in sequential
ordered fashion. Character is any value type with "cheap" copying and assignment.
</para>
<para>

View File

@ -32,9 +32,7 @@
free-standing functions and type-generators exists:</p><code>void foo( const T&, int ); <br>
int bar( T& ); <br>
foo_type_of< T >::type;</code> <br> <br><hr size="1" ><h3 >Literature</h3><ul ><li > <a href="http://www.boost.org/more/generic_programming.html#type_generator" target="_self" >Type Generators</a> </li><li > <a href="http://www.boost.org/more/generic_programming.html#concept" target="_self" >Concepts</a> </li><li > <a href="http://www.sgi.com/tech/stl/stl_introduction.html" target="_self" >Concepts and SGI STL</a> </li></ul><hr size="1" ><p >&copy; Thorsten Ottosen 2003-2004 (nesotto_AT_cs.auc.dk).
<br>Use, modification and distribution is subject to the Boost
Software License, Version 1.0. (See accompanying file
<code class="filename">LICENSE_1_0.txt</code> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</br>
</p>
<!-- Copyright Dezide Aps 2003-2004 -->
Permission to copy, use, modify, sell and distribute this software is granted provided this copyright notice appears
in all copies. This software is provided "as is" without express or implied warranty, and with no
claim as to its suitability for any purpose.</p><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br></body></html>
<!-- Copyright Dezide Aps 2003-2004 -->

View File

@ -33,7 +33,7 @@
<librarypurpose>
A set of generic string-related algorithms and utilities
</librarypurpose>
<librarycategory name="category:algorithms"/>
<librarycategory name="category:algoritms"/>
<librarycategory name="category:string-text"/>
</libraryinfo>

View File

@ -57,7 +57,7 @@
The magic of <ulink url="../../libs/range/index.html">Boost.Range</ulink>
provides a uniform way of handling different string types.
If there is a need to pass a pair of iterators,
<ulink url="../../libs/range/doc/html/range/reference/utilities/iterator_range.html"><code>boost::iterator_range</code></ulink>
<ulink url="../../libs/range/doc/utility_class.html"><code>boost::iterator_range</code></ulink>
can be used to package iterators into a structure with a compatible interface.
</para>
</listitem>
@ -130,7 +130,7 @@
string str1("command.com");
cout
&lt;&lt; str1
&lt;&lt; (is_executable("command.com")? "is": "is not")
&lt;&lt; is_executable("command.com")? "is": "is not"
&lt;&lt; "an executable"
&lt;&lt; endl; // prints "command.com is an executable"
@ -138,7 +138,7 @@
char text1[]="hello world!";
cout
&lt;&lt; text1
&lt;&lt; (all( text1, is_lower() )? "is": "is not")
&lt;&lt; all( text1, is_lower() )? "is": "is not"
&lt;&lt; " written in the lower case"
&lt;&lt; endl; // prints "hello world! is written in the lower case"
</programlisting>
@ -169,7 +169,7 @@
<programlisting>
string str1=" hello world! ";
string str2=trim_left_copy(str1); // str2 == "hello world! "
string str3=trim_right_copy(str1); // str3 == " hello world!"
string str3=trim_right_copy(str2); // str3 == " hello world!"
trim(str1); // str1 == "hello world!"
string phone="00423333444";
@ -208,7 +208,7 @@
</programlisting>
<para>
We have used <functionname>find_last()</functionname> to search the <code>text</code> for "ll".
The result is given in the <ulink url="../../libs/range/doc/html/range/reference/utilities/iterator_range.html"><code>boost::iterator_range</code></ulink>.
The result is given in the <ulink url="../../libs/range/doc/utility_class.html"><code>boost::iterator_range</code></ulink>.
This range delimits the
part of the input which satisfies the find criteria. In our example it is the last occurrence of "ll".
@ -217,7 +217,7 @@
<ulink url="../../libs/range/index.html">Boost.Range</ulink>.
The following lines transform the result. Notice that
<ulink url="../../libs/range/doc/html/range/reference/utilities/iterator_range.html"><code>boost::iterator_range</code></ulink> has familiar
<ulink url="../../libs/range/doc/utility_class.html"><code>boost::iterator_range</code></ulink> has familiar
<code>begin()</code> and <code>end()</code> methods, so it can be used like any other STL container.
Also it is convertible to bool therefore it is easy to use find algorithms for a simple containment checking.
</para>
@ -264,7 +264,7 @@
the find iterator allows us to iterate over the substrings matching the specified criteria.
This facility is using the <link linkend="string_algo.finder_concept">Finder</link> to incrementally
search the string.
Dereferencing a find iterator yields an <ulink url="../../libs/range/doc/html/range/reference/utilities/iterator_range.html"><code>boost::iterator_range</code></ulink>
Dereferencing a find iterator yields an <ulink url="../../libs/range/doc/utility_class.html"><code>boost::iterator_range</code></ulink>
object, that delimits the current match.
</para>
<para>
@ -339,7 +339,7 @@
typedef vector&lt; string &gt; split_vector_type;
split_vector_type SplitVec; // #2: Search for tokens
split( SplitVec, str1, is_any_of("-*"), token_compress_on ); // SplitVec == { "hello abc","ABC","aBc goodbye" }
split( SplitVec, str1, is_any_of("-*") ); // SplitVec == { "hello abc","ABC","aBc goodbye" }
</programlisting>
<para>
<code>[hello]</code> designates an <code>iterator_range</code> delimiting this substring.

View File

@ -0,0 +1,16 @@
#-------------------------------------------------------------------------
#-- Needed include directories for the tests
boost_test_add_dependent_includes("utility;detail;config;test;mpl;bind;type_traits;static_assert;preprocessor;array;iterator;exception;range;timer")
#-------------------------------------------------------------------------
boost_test_run(trim_test)
boost_test_run(conv_test)
boost_test_run(predicate_test)
boost_test_run(find_test)
boost_test_run(split_test)
boost_test_run(join_test)
boost_test_run(replace_test)
boost_test_run(regex_test DEPENDS boost_regex SHARED)

View File

@ -59,11 +59,5 @@ test-suite algorithm/string
:
: regex
]
[ run
find_format_test.cpp
: :
:
: find_format
]
;

View File

@ -1,163 +0,0 @@
// Boost string_algo library find_format_test.cpp file ------------------//
// Copyright (c) 2009 Steven Watanabe
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// See http://www.boost.org for updates, documentation, and revision history.
#include <boost/algorithm/string/find_format.hpp>
#include <boost/algorithm/string/finder.hpp>
#include <boost/algorithm/string/formatter.hpp>
// Include unit test framework
#include <boost/test/included/test_exec_monitor.hpp>
#include <boost/test/test_tools.hpp>
// We're only using const_formatter.
template<class Formatter>
struct formatter_result {
typedef boost::iterator_range<const char*> type;
};
template<class Formatter>
struct checked_formatter {
public:
checked_formatter(const Formatter& formatter) : formatter_(formatter) {}
template< typename T >
typename formatter_result<Formatter>::type operator()( const T & s ) const {
BOOST_CHECK( !s.empty() );
return formatter_(s);
}
private:
Formatter formatter_;
};
template<class Formatter>
checked_formatter<Formatter>
make_checked_formatter(const Formatter& formatter) {
return checked_formatter<Formatter>(formatter);
}
void find_format_test()
{
const std::string source = "$replace $replace";
std::string expected = "ok $replace";
std::string output(80, '\0');
std::string::iterator pos =
boost::find_format_copy(
output.begin(),
source,
boost::first_finder("$replace"),
make_checked_formatter(boost::const_formatter("ok")));
BOOST_CHECK(pos == output.begin() + expected.size());
output.erase(std::remove(output.begin(), output.end(), '\0'), output.end());
BOOST_CHECK_EQUAL(output, expected);
output =
boost::find_format_copy(
source,
boost::first_finder("$replace"),
make_checked_formatter(boost::const_formatter("ok")));
BOOST_CHECK_EQUAL(output, expected);
// now try finding a string that doesn't exist
output.resize(80);
pos =
boost::find_format_copy(
output.begin(),
source,
boost::first_finder("$noreplace"),
make_checked_formatter(boost::const_formatter("bad")));
BOOST_CHECK(pos == output.begin() + source.size());
output.erase(std::remove(output.begin(), output.end(), '\0'), output.end());
BOOST_CHECK_EQUAL(output, source);
output =
boost::find_format_copy(
source,
boost::first_finder("$noreplace"),
make_checked_formatter(boost::const_formatter("bad")));
BOOST_CHECK_EQUAL(output, source);
// in place version
output = source;
boost::find_format(
output,
boost::first_finder("$replace"),
make_checked_formatter(boost::const_formatter("ok")));
BOOST_CHECK_EQUAL(output, expected);
output = source;
boost::find_format(
output,
boost::first_finder("$noreplace"),
make_checked_formatter(boost::const_formatter("bad")));
BOOST_CHECK_EQUAL(output, source);
}
void find_format_all_test()
{
const std::string source = "$replace $replace";
std::string expected = "ok ok";
std::string output(80, '\0');
std::string::iterator pos =
boost::find_format_all_copy(output.begin(),
source,
boost::first_finder("$replace"),
boost::const_formatter("ok"));
BOOST_CHECK(pos == output.begin() + expected.size());
output.erase(std::remove(output.begin(), output.end(), '\0'), output.end());
BOOST_CHECK_EQUAL(output, expected);
output =
boost::find_format_all_copy(
source,
boost::first_finder("$replace"),
make_checked_formatter(boost::const_formatter("ok")));
BOOST_CHECK_EQUAL(output, expected);
// now try finding a string that doesn't exist
output.resize(80);
pos =
boost::find_format_all_copy(
output.begin(),
source,
boost::first_finder("$noreplace"),
make_checked_formatter(boost::const_formatter("bad")));
BOOST_CHECK(pos == output.begin() + source.size());
output.erase(std::remove(output.begin(), output.end(), '\0'), output.end());
BOOST_CHECK_EQUAL(output, source);
output =
boost::find_format_all_copy(
source,
boost::first_finder("$noreplace"),
make_checked_formatter(boost::const_formatter("bad")));
BOOST_CHECK_EQUAL(output, source);
// in place version
output = source;
boost::find_format_all(
output,
boost::first_finder("$replace"),
make_checked_formatter(boost::const_formatter("ok")));
BOOST_CHECK_EQUAL(output, expected);
output = source;
boost::find_format_all(
output,
boost::first_finder("$noreplace"),
make_checked_formatter(boost::const_formatter("bad")));
BOOST_CHECK_EQUAL(output, source);
}
int test_main( int, char*[] )
{
find_format_test();
find_format_all_test();
return 0;
}

View File

@ -40,7 +40,6 @@ void iterator_test()
string str1("xx-abc--xx-abb");
string str2("Xx-abc--xX-abb-xx");
string str3("xx");
string strempty("");
const char* pch1="xx-abc--xx-abb";
vector<string> tokens;
vector< vector<int> > vtokens;
@ -124,25 +123,6 @@ void iterator_test()
BOOST_CHECK( tokens[3]==string("xx") );
BOOST_CHECK( tokens[4]==string("abb") );
split(
tokens,
str3,
is_any_of(","),
token_compress_off);
BOOST_REQUIRE( tokens.size()==1 );
BOOST_CHECK( tokens[0]==string("xx") );
split(
tokens,
strempty,
is_punct(),
token_compress_off);
BOOST_REQUIRE( tokens.size()==1 );
BOOST_CHECK( tokens[0]==string("") );
find_iterator<string::iterator> fiter=make_find_iterator(str1, first_finder("xx"));
BOOST_CHECK(equals(*fiter, "xx"));
++fiter;
@ -159,7 +139,6 @@ void iterator_test()
++siter;
BOOST_CHECK(equals(*siter, "abb"));
++siter;
BOOST_CHECK(siter==split_iterator<string::iterator>(siter));
BOOST_CHECK(siter==split_iterator<string::iterator>());
}