feedc0de/boost_algorithm
1
0
Fork 0
forked from boostorg/algorithm
Code Pull Requests Activity

merged from trunk

Browse Source 
[SVN r47983]
This commit is contained in:
Eric Niebler
2008-08-05 05:39:57 +00:00
parent f62e23a14c
commit 4e17ef2b40
23 changed files with 295 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
include/boost/algorithm/string/detail/case_conv.hpp
View File

@ -21,6 +21,11 @@ namespace boost {
// case conversion functors -----------------------------------------------//
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
#pragma warning(push)
#pragma warning(disable:4512) //assignment operator could not be generated
#endif
// a tolower functor
template<typename CharT>
struct to_lowerF : public std::unary_function<CharT, CharT>
@ -61,6 +66,10 @@ namespace boost {
const std::locale& m_Loc;
};
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
#pragma warning(pop)
#endif
// algorithm implementation -------------------------------------------------------------------------
// Transform a range
@ -71,8 +80,8 @@ namespace boost {
FunctorT Functor)
{
return std::transform(
begin(Input),
end(Input),
::boost::begin(Input),
::boost::end(Input),
Output,
Functor);
}
@ -84,9 +93,9 @@ namespace boost {
FunctorT Functor)
{
std::transform(
begin(Input),
end(Input),
begin(Input),
::boost::begin(Input),
::boost::end(Input),
::boost::begin(Input),
Functor);
}
@ -97,10 +106,10 @@ namespace boost {
{
return SequenceT(
make_transform_iterator(
begin(Input),
::boost::begin(Input),
Functor),
make_transform_iterator(
end(Input),
::boost::end(Input),
Functor));
}

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

@ -15,7 +15,6 @@
#include <algorithm>
#include <functional>
#include <locale>
#include <set>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
@ -29,6 +28,10 @@ namespace boost {
// classification functors -----------------------------------------------//
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
#pragma warning(push)
#pragma warning(disable:4512) //assignment operator could not be generated
#endif
// is_classified functor
struct is_classifiedF :
public predicate_facade<is_classifiedF>
@ -60,6 +63,10 @@ namespace boost {
const std::locale m_Locale;
};
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
#pragma warning(pop)
#endif
// is_any_of functor
/*
returns true if the value is from the specified set
@ -68,25 +75,132 @@ namespace boost {
struct is_any_ofF :
public predicate_facade<is_any_ofF<CharT> >
{
private:
// set cannot operate on const value-type
typedef typename remove_const<CharT>::type set_value_type;
// Size of the static storage (size of pointer*2)
static const ::std::size_t FIXED_STORAGE_SIZE = sizeof(set_value_type*)*2;
public:
// Boost.Lambda support
template <class Args> struct sig { typedef bool type; };
// Constructor
template<typename RangeT>
is_any_ofF( const RangeT& Range ) :
m_Set( begin(Range), end(Range) ) {}
is_any_ofF( const RangeT& Range ) : m_Size(0)
{
// Prepare storage
m_Storage.m_dynSet=0;
std::size_t Size=::boost::distance(Range);
m_Size=Size;
set_value_type* Storage=0;
if(m_Size<=FIXED_STORAGE_SIZE)
{
// Use fixed storage
Storage=&m_Storage.m_fixSet[0];
}
else
{
// Use dynamic storage
m_Storage.m_dynSet=new set_value_type[m_Size];
Storage=m_Storage.m_dynSet;
}
// Use fixed storage
::std::copy(::boost::begin(Range), ::boost::end(Range), Storage);
::std::sort(Storage, Storage+m_Size);
}
// Copy constructor
is_any_ofF(const is_any_ofF& Other) : m_Size(Other.m_Size)
{
// Prepare storage
m_Storage.m_dynSet=0;
const set_value_type* SrcStorage=0;
set_value_type* DestStorage=0;
if(m_Size<=FIXED_STORAGE_SIZE)
{
// Use fixed storage
DestStorage=&m_Storage.m_fixSet[0];
SrcStorage=&Other.m_Storage.m_fixSet[0];
}
else
{
// Use dynamic storage
m_Storage.m_dynSet=new set_value_type[m_Size];
DestStorage=m_Storage.m_dynSet;
SrcStorage=Other.m_Storage.m_dynSet;
}
// Use fixed storage
::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
}
// Destructor
~is_any_ofF()
{
if(m_Size>FIXED_STORAGE_SIZE && m_Storage.m_dynSet!=0)
{
delete m_Storage.m_dynSet;
}
}
// Assignment
is_any_ofF& operator=(const is_any_ofF& Other)
{
// Prepare storage
m_Storage.m_dynSet=0;
m_Size=Other.m_Size;
const set_value_type* SrcStorage=0;
set_value_type* DestStorage=0;
if(m_Size<=FIXED_STORAGE_SIZE)
{
// Use fixed storage
DestStorage=&m_Storage.m_fixSet[0];
SrcStorage=&Other.m_Storage.m_fixSet[0];
}
else
{
// Use dynamic storage
m_Storage.m_dynSet=new set_value_type[m_Size];
DestStorage=m_Storage.m_dynSet;
SrcStorage=Other.m_Storage.m_dynSet;
}
// Use fixed storage
::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
return *this;
}
// Operation
template<typename Char2T>
bool operator()( Char2T Ch ) const
{
return m_Set.find(Ch)!=m_Set.end();
const set_value_type* Storage=
(m_Size<=FIXED_STORAGE_SIZE)
? &m_Storage.m_fixSet[0]
: m_Storage.m_dynSet;
return ::std::binary_search(Storage, Storage+m_Size, Ch);
}
private:
// set cannot operate on const value-type
typedef typename remove_const<CharT>::type set_value_type;
std::set<set_value_type> m_Set;
// storage
// The actual used storage is selected on the type
union
{
set_value_type* m_dynSet;
set_value_type m_fixSet[FIXED_STORAGE_SIZE];
}
m_Storage;
// storage size
::std::size_t m_Size;
};
// is_from_range functor

14
include/boost/algorithm/string/detail/find_format.hpp
View File

@ -68,17 +68,17 @@ namespace boost {
if ( !M )
{
// Match not found - return original sequence
std::copy( begin(Input), end(Input), Output );
std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
return Output;
}
// Copy the beginning of the sequence
std::copy( begin(Input), begin(M), Output );
std::copy( ::boost::begin(Input), ::boost::begin(M), Output );
// Format find result
// Copy formated result
std::copy( begin(M.format_result()), end(M.format_result()), Output );
std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
// Copy the rest of the sequence
std::copy( M.end(), end(Input), Output );
std::copy( M.end(), ::boost::end(Input), Output );
return Output;
}
@ -129,11 +129,11 @@ namespace boost {
InputT Output;
// Copy the beginning of the sequence
insert( Output, end(Output), begin(Input), M.begin() );
insert( Output, ::boost::end(Output), ::boost::begin(Input), M.begin() );
// Copy formated result
insert( Output, end(Output), M.format_result() );
insert( Output, ::boost::end(Output), M.format_result() );
// Copy the rest of the sequence
insert( Output, end(Output), M.end(), end(Input) );
insert( Output, ::boost::end(Output), M.end(), ::boost::end(Input) );
return Output;
}

30
include/boost/algorithm/string/detail/find_format_all.hpp
View File

@ -73,7 +73,7 @@ namespace boost {
store_type M( FindResult, FormatResult, Formatter );
// Initialize last match
input_iterator_type LastMatch=begin(Input);
input_iterator_type LastMatch=::boost::begin(Input);
// Iterate through all matches
while( M )
@ -81,15 +81,15 @@ namespace boost {
// Copy the beginning of the sequence
std::copy( LastMatch, M.begin(), Output );
// Copy formated result
std::copy( begin(M.format_result()), 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();
M=Finder( LastMatch, end(Input) );
M=Finder( LastMatch, ::boost::end(Input) );
}
// Copy the rest of the sequence
std::copy( LastMatch, end(Input), Output );
std::copy( LastMatch, ::boost::end(Input), Output );
return Output;
}
@ -140,7 +140,7 @@ namespace boost {
store_type M( FindResult, FormatResult, Formatter );
// Initialize last match
input_iterator_type LastMatch=begin(Input);
input_iterator_type LastMatch=::boost::begin(Input);
// Output temporary
InputT Output;
@ -149,17 +149,17 @@ namespace boost {
while( M )
{
// Copy the beginning of the sequence
insert( Output, end(Output), LastMatch, M.begin() );
insert( Output, ::boost::end(Output), LastMatch, M.begin() );
// Copy formated result
insert( Output, end(Output), M.format_result() );
insert( Output, ::boost::end(Output), M.format_result() );
// Proceed to the next match
LastMatch=M.end();
M=Finder( LastMatch, end(Input) );
M=Finder( LastMatch, ::boost::end(Input) );
}
// Copy the rest of the sequence
insert( Output, end(Output), LastMatch, end(Input) );
insert( Output, ::boost::end(Output), LastMatch, ::boost::end(Input) );
return Output;
}
@ -213,8 +213,8 @@ namespace boost {
BOOST_STRING_TYPENAME range_value<InputT>::type> Storage;
// Initialize replacement iterators
input_iterator_type InsertIt=begin(Input);
input_iterator_type SearchIt=begin(Input);
input_iterator_type InsertIt=::boost::begin(Input);
input_iterator_type SearchIt=::boost::begin(Input);
while( M )
{
@ -233,7 +233,7 @@ namespace boost {
copy_to_storage( Storage, M.format_result() );
// Find range for a next match
M=Finder( SearchIt, end(Input) );
M=Finder( SearchIt, ::boost::end(Input) );
}
// process the last segment
@ -242,17 +242,17 @@ namespace boost {
Input,
InsertIt,
SearchIt,
end(Input) );
::boost::end(Input) );
if ( Storage.empty() )
{
// Truncate input
erase( Input, InsertIt, end(Input) );
erase( Input, InsertIt, ::boost::end(Input) );
}
else
{
// Copy remaining data to the end of input
insert( Input, end(Input), Storage.begin(), Storage.end() );
insert( Input, ::boost::end(Input), Storage.begin(), Storage.end() );
}
}

7
include/boost/algorithm/string/detail/find_format_store.hpp
View File

@ -20,6 +20,10 @@ namespace boost {
// temporary format and find result storage --------------------------------//
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
#pragma warning(push)
#pragma warning(disable:4512) //assignment operator could not be generated
#endif
template<
typename ForwardIteratorT,
typename FormatterT,
@ -64,6 +68,9 @@ namespace boost {
const formatter_type& m_Formatter;
};
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
#pragma warning(pop)
#endif
} // namespace detail
} // namespace algorithm
} // namespace boost

12
include/boost/algorithm/string/detail/finder.hpp
View File

@ -41,7 +41,7 @@ namespace boost {
// Construction
template< typename SearchT >
first_finderF( const SearchT& Search, PredicateT Comp ) :
m_Search(begin(Search), end(Search)), m_Comp(Comp) {}
m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
first_finderF(
search_iterator_type SearchBegin,
search_iterator_type SearchEnd,
@ -108,7 +108,7 @@ namespace boost {
// Construction
template< typename SearchT >
last_finderF( const SearchT& Search, PredicateT Comp ) :
m_Search(begin(Search), end(Search)), m_Comp(Comp) {}
m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
last_finderF(
search_iterator_type SearchBegin,
search_iterator_type SearchEnd,
@ -154,7 +154,7 @@ namespace boost {
while( M )
{
Last=M;
M=first_finder( end(M), End );
M=first_finder( ::boost::end(M), End );
}
return Last;
@ -224,7 +224,7 @@ namespace boost {
const SearchT& Search,
int Nth,
PredicateT Comp) :
m_Search(begin(Search), end(Search)),
m_Search(::boost::begin(Search), ::boost::end(Search)),
m_Nth(Nth),
m_Comp(Comp) {}
nth_finderF(
@ -279,7 +279,7 @@ namespace boost {
for( unsigned int n=0; n<=N; ++n )
{
// find next match
M=first_finder( end(M), End );
M=first_finder( ::boost::end(M), End );
if ( !M )
{
@ -314,7 +314,7 @@ namespace boost {
for( unsigned int n=1; n<=N; ++n )
{
// find next match
M=last_finder( Begin, begin(M) );
M=last_finder( Begin, ::boost::begin(M) );
if ( !M )
{

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

@ -39,7 +39,7 @@ namespace boost {
public:
// Construction
const_formatF(const RangeT& Format) :
m_Format(begin(Format), end(Format)) {}
m_Format(::boost::begin(Format), ::boost::end(Format)) {}
// Operation
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
@ -70,7 +70,7 @@ namespace boost {
template< typename Range2T >
const RangeT& operator()(const Range2T& Replace) const
{
return RangeT(begin(Replace), end(Replace));
return RangeT(::boost::begin(Replace), ::boost::end(Replace));
}
};

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

@ -46,7 +46,7 @@ namespace boost {
StorageT& Storage,
const WhatT& What )
{
Storage.insert( Storage.end(), begin(What), end(What) );
Storage.insert( Storage.end(), ::boost::begin(What), ::boost::end(What) );
}

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

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