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

Boost.Range fixes for compilers that were having problems picking between const and mutable range overloads of range algorithms.

Browse Source 
[SVN r61028]
This commit is contained in:
Neil Groves
2010-04-03 21:00:56 +00:00
parent f8f29ae7d3
commit d0544400af
14 changed files with 54 additions and 380 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
doc/reference/algorithm/find.qbk
View File

@ -7,10 +7,6 @@ template<class SinglePassRange, class Value>
typename range_iterator<SinglePassRange>::type
find(SinglePassRange& rng, Value val);
template<class SinglePassRange, class Value>
typename range_iterator<const SinglePassRange>::type
find(const SinglePassRange& rng, Value val);
template<
range_return_value re,
class SinglePassRange,
@ -18,14 +14,6 @@ template<
>
typename range_return<SinglePassRange, re>::type
find(SinglePassRange& rng, Value val);
template<
range_return_value re,
class SinglePassRange,
class Value
>
typename range_return<const SinglePassRange, re>::type
find(const SinglePassRange& rng, Value val);
``
[heading Description]

30
doc/reference/algorithm/find_end.qbk
View File

@ -7,10 +7,6 @@ template<class ForwardRange1, class ForwardRange2>
typename range_iterator<ForwardRange1>::type
find_end(ForwardRange1& rng1, const ForwardRange2& rng2);
template<class ForwardRange1, class ForwardRange2>
typename range_iterator<const ForwardRange1>::type
find_end(const ForwardRange1& rng1, const ForwardRange2& rng2);
template<
class ForwardRange1,
class ForwardRange2,
@ -19,15 +15,6 @@ template<
typename range_iterator<ForwardRange1>::type
find_end(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred);
template<
class ForwardRange1,
class ForwardRange2,
class BinaryPredicate
>
typename range_iterator<const ForwardRange1>::type
find_end(const ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred);
template<
range_return_value re,
class ForwardRange1,
@ -36,14 +23,6 @@ template<
typename range_return<ForwardRange1, re>::type
find_end(ForwardRange1& rng1, const ForwardRange2& rng2);
template<
range_return_value re,
class ForwardRange1,
class ForwardRange2
>
typename range_return<const ForwardRange1, re>::type
find_end(const ForwardRange1& rng1, const ForwardRange2& rng2);
template<
range_return_value re,
class ForwardRange1,
@ -52,15 +31,6 @@ template<
>
typename range_return<ForwardRange1, re>::type
find_end(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred);
template<
range_return_value re,
class ForwardRange1,
class ForwardRange2,
class BinaryPredicate
>
typename range_return<const ForwardRange1, re>::type
find_end(const ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred);
``
[heading Description]

30
doc/reference/algorithm/find_first_of.qbk
View File

@ -7,10 +7,6 @@ template<class SinglePassRange1, class ForwardRange2>
typename range_iterator<SinglePassRange1>::type
find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2);
template<class SinglePassRange1, class ForwardRange2>
typename range_iterator<const SinglePassRange1>::type
find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2);
template<
class SinglePassRange1,
class ForwardRange2,
@ -19,15 +15,6 @@ template<
typename range_iterator<SinglePassRange1>::type
find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred);
template<
class SinglePassRange1,
class ForwardRange2,
class BinaryPredicate
>
typename range_iterator<const SinglePassRange1>::type
find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred);
template<
range_return_value re,
class SinglePassRange1,
@ -36,14 +23,6 @@ template<
typename range_return<SinglePassRange1, re>::type
find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2);
template<
range_return_value re,
class SinglePassRange1,
class ForwardRange2
>
typename range_return<const SinglePassRange1, re>::type
find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2);
template<
range_return_value re,
class SinglePassRange1,
@ -52,15 +31,6 @@ template<
>
typename range_return<SinglePassRange1, re>::type
find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred);
template<
range_return_value re,
class SinglePassRange1,
class ForwardRange2,
class BinaryPredicate
>
typename range_return<const SinglePassRange1, re>::type
find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred);
``
[heading Description]

12
doc/reference/algorithm/find_if.qbk
View File

@ -7,10 +7,6 @@ template<class SinglePassRange, class UnaryPredicate>
typename range_iterator<SinglePassRange>::type
find_if(SinglePassRange& rng, UnaryPredicate pred);
template<class SinglePassRange, class UnaryPredicate>
typename range_iterator<const SinglePassRange>::type
find_if(const SinglePassRange& rng, UnaryPredicate pred);
template<
range_return_value re,
class SinglePassRange,
@ -18,14 +14,6 @@ template<
>
typename range_return<SinglePassRange, re>::type
find_if(SinglePassRange& rng, UnaryPredicate pred);
template<
range_return_value re,
class SinglePassRange,
class UnaryPredicate
>
typename range_return<const SinglePassRange, re>::type
find_if(const SinglePassRange& rng, UnaryPredicate pred);
``
[heading Description]

12
doc/reference/algorithm/lower_bound.qbk
View File

@ -7,10 +7,6 @@ template<class ForwardRange, class Value>
typename range_iterator<ForwardRange>::type
lower_bound(ForwardRange& rng, Value val);
template<class ForwardRange, class Value>
typename range_iterator<const ForwardRange>::type
lower_bound(const ForwardRange& rng, Value val);
template<
range_return_value re,
class ForwardRange,
@ -18,14 +14,6 @@ template<
>
typename range_return<ForwardRange, re>::type
lower_bound(ForwardRange& rng, Value val);
template<
range_return_value re,
class ForwardRange,
class Value
>
typename range_return<const ForwardRange, re>::type
lower_bound(const ForwardRange& rng, Value val);
``
[heading Description]

12
doc/reference/algorithm/upper_bound.qbk
View File

@ -7,10 +7,6 @@ template<class ForwardRange, class Value>
typename range_iterator<ForwardRange>::type
upper_bound(ForwardRange& rng, Value val);
template<class ForwardRange, class Value>
typename range_iterator<const ForwardRange>::type
upper_bound(const ForwardRange& rng, Value val);
template<
range_return_value re,
class ForwardRange,
@ -18,14 +14,6 @@ template<
>
typename range_return<ForwardRange, re>::type
upper_bound(ForwardRange& rng, Value val);
template<
range_return_value re,
class ForwardRange,
class Value
>
typename range_return<const ForwardRange, re>::type
upper_bound(const ForwardRange& rng, Value val);
``
[heading Description]

18
include/boost/range/algorithm/find.hpp
View File

@ -33,14 +33,6 @@ find( SinglePassRange& rng, const Value& val )
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::find(boost::begin(rng), boost::end(rng), val);
}
/// \overload
template< class SinglePassRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type
find( const SinglePassRange& rng, const Value& val )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::find(boost::begin(rng), boost::end(rng), val);
}
// range_return overloads
@ -54,16 +46,6 @@ find( SinglePassRange& rng, const Value& val )
pack(std::find(boost::begin(rng), boost::end(rng), val),
rng);
}
/// \overload
template< range_return_value re, class SinglePassRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type
find( const SinglePassRange& rng, const Value& val )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return range_return<const SinglePassRange,re>::
pack(std::find(boost::begin(rng), boost::end(rng), val),
rng);
}
} // namespace range
using range::find;

59
include/boost/range/algorithm/find_end.hpp
View File

@ -30,7 +30,7 @@ namespace boost
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template< class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_iterator< ForwardRange1 >::type
find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2)
find_end(ForwardRange1 & rng1, const ForwardRange2& rng2)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
@ -39,23 +39,10 @@ find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2)
boost::begin(rng2),boost::end(rng2));
}
/// \overload
template< class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_end(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2));
}
/// \overload
template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
find_end(ForwardRange1 & rng1, const ForwardRange2& rng2, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
@ -64,18 +51,6 @@ find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
boost::begin(rng2),boost::end(rng2),pred);
}
/// \overload
template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_end(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred);
}
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
@ -90,20 +65,6 @@ find_end(ForwardRange1& rng1, const ForwardRange2& rng2)
rng1);
}
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
find_end(const ForwardRange1& rng1, const ForwardRange2& rng2)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<const ForwardRange1,re>::
pack(std::find_end(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2)),
rng1);
}
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2,
class BinaryPredicate >
@ -119,22 +80,6 @@ find_end(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
rng1);
}
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2,
class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
find_end(const ForwardRange1& rng1, const ForwardRange2& rng2,
BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<const ForwardRange1,re>::
pack(std::find_end(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred),
rng1);
}
} // namespace range
using range::find_end;
} // namespace boost

55
include/boost/range/algorithm/find_first_of.hpp
View File

@ -39,18 +39,6 @@ find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2)
boost::begin(rng2),boost::end(rng2));
}
/// \overload
template< class SinglePassRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type
find_first_of(SinglePassRange1 const & rng1, ForwardRange2 const & rng2)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_first_of(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2));
}
/// \overload
template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
@ -63,19 +51,6 @@ find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2, BinaryPredica
boost::begin(rng2),boost::end(rng2),pred);
}
/// \overload
template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type
find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2,
BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_first_of(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred);
}
// range return overloads
/// \overload
template< range_return_value re, class SinglePassRange1, class ForwardRange2 >
@ -91,20 +66,6 @@ find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2)
rng1);
}
/// \overload
template< range_return_value re, class SinglePassRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange1,re>::type
find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<const SinglePassRange1,re>::
pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2)),
rng1);
}
/// \overload
template< range_return_value re, class SinglePassRange1, class ForwardRange2,
class BinaryPredicate >
@ -121,22 +82,6 @@ find_first_of(SinglePassRange1 & rng1, const ForwardRange2& rng2,
rng1);
}
/// \overload
template< range_return_value re, class SinglePassRange1, class ForwardRange2,
class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange1,re>::type
find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2,
BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange2> ));
return range_return<const SinglePassRange1,re>::
pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2),pred),
rng1);
}
} // namespace range
using range::find_first_of;
} // namespace boost

18
include/boost/range/algorithm/find_if.hpp
View File

@ -34,14 +34,6 @@ find_if( SinglePassRange& rng, UnaryPredicate pred )
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::find_if(boost::begin(rng), boost::end(rng), pred);
}
/// \overload
template< class SinglePassRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type
find_if( const SinglePassRange& rng, UnaryPredicate pred )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::find_if(boost::begin(rng), boost::end(rng), pred);
}
// range_return overloads
@ -55,16 +47,6 @@ find_if( SinglePassRange& rng, UnaryPredicate pred )
pack(std::find_if(boost::begin(rng), boost::end(rng), pred),
rng);
}
/// \overload
template< range_return_value re, class SinglePassRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type
find_if( const SinglePassRange& rng, UnaryPredicate pred )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return range_return<const SinglePassRange,re>::
pack(std::find_if(boost::begin(rng), boost::end(rng), pred),
rng);
}
} // namespace range
using range::find_if;

36
include/boost/range/algorithm/lower_bound.hpp
View File

@ -34,14 +34,6 @@ lower_bound( ForwardRange& rng, Value val )
return std::lower_bound(boost::begin(rng), boost::end(rng), val);
}
/// \overload
template< class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
lower_bound( const ForwardRange& rng, Value val )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::lower_bound(boost::begin(rng), boost::end(rng), val);
}
/// \overload
template< class ForwardRange, class Value, class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
@ -50,14 +42,6 @@ lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred);
}
/// \overload
template< class ForwardRange, class Value, class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
lower_bound( const ForwardRange& rng, Value val, SortPredicate pred )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred);
}
/// \overload
template< range_return_value re, class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
lower_bound( ForwardRange& rng, Value val )
@ -68,16 +52,6 @@ lower_bound( ForwardRange& rng, Value val )
rng);
}
/// \overload
template< range_return_value re, class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
lower_bound( const ForwardRange& rng, Value val )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::
pack(std::lower_bound(boost::begin(rng), boost::end(rng), val),
rng);
}
/// \overload
template< range_return_value re, class ForwardRange, class Value, class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
@ -87,16 +61,6 @@ lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred),
rng);
}
/// \overload
template< range_return_value re, class ForwardRange, class Value, class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
lower_bound( const ForwardRange& rng, Value val, SortPredicate pred )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::
pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred),
rng);
}
} // namespace range
using range::lower_bound;

36
include/boost/range/algorithm/upper_bound.hpp
View File

@ -34,13 +34,6 @@ upper_bound( ForwardRange& rng, Value val )
return std::upper_bound(boost::begin(rng), boost::end(rng), val);
}
/// \overload
template< class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
upper_bound( const ForwardRange& rng, Value val )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::upper_bound(boost::begin(rng), boost::end(rng), val);
}
/// \overload
template< class ForwardRange, class Value, class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
@ -50,14 +43,6 @@ upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred);
}
/// \overload
template< class ForwardRange, class Value, class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
upper_bound( const ForwardRange& rng, Value val, SortPredicate pred )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred);
}
/// \overload
template< range_return_value re, class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
upper_bound( ForwardRange& rng, Value val )
@ -68,16 +53,6 @@ upper_bound( ForwardRange& rng, Value val )
rng);
}
/// \overload
template< range_return_value re, class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
upper_bound( const ForwardRange& rng, Value val )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::
pack(std::upper_bound(boost::begin(rng), boost::end(rng), val),
rng);
}
/// \overload
template< range_return_value re, class ForwardRange, class Value,
class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
@ -88,17 +63,6 @@ upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred),
rng);
}
/// \overload
template< range_return_value re, class ForwardRange, class Value,
class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
upper_bound( const ForwardRange& rng, Value val, SortPredicate pred )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::
pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred),
rng);
}
} // namespace range
using range::upper_bound;

4
test/algorithm_test/find.cpp
View File

@ -86,6 +86,10 @@ namespace boost
test_find_container< const std::vector<int> >();
test_find_container< const std::list<int> >();
test_find_container< const std::deque<int> >();
std::vector<int> vi;
const std::vector<int>& cvi = vi;
std::vector<int>::const_iterator it = boost::find(vi, 0);
}
}
}

72
test/sub_range.cpp Executable file → Normal file
View File

@ -23,36 +23,33 @@
#include <string>
#include <vector>
using namespace boost;
using namespace std;
void check_sub_range()
{
typedef string::iterator iterator;
typedef string::const_iterator const_iterator;
typedef iterator_range<iterator> irange;
typedef iterator_range<const_iterator> cirange;
string str = "hello world";
const string cstr = "const world";
irange r = make_iterator_range( str );
r = make_iterator_range( str.begin(), str.end() );
cirange r2 = make_iterator_range( cstr );
r2 = make_iterator_range( cstr.begin(), cstr.end() );
r2 = make_iterator_range( str );
typedef std::string::iterator iterator;
typedef std::string::const_iterator const_iterator;
typedef boost::iterator_range<iterator> irange;
typedef boost::iterator_range<const_iterator> cirange;
std::string str = "hello world";
const std::string cstr = "const world";
irange r = boost::make_iterator_range( str );
r = boost::make_iterator_range( str.begin(), str.end() );
cirange r2 = boost::make_iterator_range( cstr );
r2 = boost::make_iterator_range( cstr.begin(), cstr.end() );
r2 = boost::make_iterator_range( str );
typedef sub_range<string> srange;
typedef sub_range<const string> csrange;
typedef boost::sub_range<std::string> srange;
typedef boost::sub_range<const std::string> csrange;
srange s = r;
BOOST_CHECK( r == r );
BOOST_CHECK( s == r );
s = make_iterator_range( str );
s = boost::make_iterator_range( str );
csrange s2 = r;
s2 = r2;
s2 = make_iterator_range( cstr );
s2 = boost::make_iterator_range( cstr );
BOOST_CHECK( r2 == r2 );
BOOST_CHECK( s2 != r2 );
s2 = make_iterator_range( str );
s2 = boost::make_iterator_range( str );
BOOST_CHECK( !(s != s) );
BOOST_CHECK( r.begin() == s.begin() );
@ -82,10 +79,10 @@ void check_sub_range()
BOOST_CHECK( false );
//#endif
cout << r << r2 << s << s2;
std::cout << r << r2 << s << s2;
string res = copy_range<string>( r );
BOOST_CHECK( equal( res.begin(), res.end(), r.begin() ) );
std::string res = boost::copy_range<std::string>( r );
BOOST_CHECK_EQUAL_COLLECTIONS( res.begin(), res.end(), r.begin(), r.end() );
r.empty();
s.empty();
@ -107,44 +104,43 @@ void check_sub_range()
//BOOST_CHECK( empty( singular_srange ) );
//
srange rr = make_iterator_range( str );
srange rr = boost::make_iterator_range( str );
BOOST_CHECK( rr.equal( r ) );
rr = make_iterator_range( str.begin(), str.begin() + 5 );
BOOST_CHECK( rr == as_literal("hello") );
BOOST_CHECK( rr != as_literal("hell") );
BOOST_CHECK( rr < as_literal("hello dude") );
BOOST_CHECK( as_literal("hello") == rr );
BOOST_CHECK( as_literal("hell") != rr );
BOOST_CHECK( ! (as_literal("hello dude") < rr ) );
rr = boost::make_iterator_range( str.begin(), str.begin() + 5 );
BOOST_CHECK( rr == boost::as_literal("hello") );
BOOST_CHECK( rr != boost::as_literal("hell") );
BOOST_CHECK( rr < boost::as_literal("hello dude") );
BOOST_CHECK( boost::as_literal("hello") == rr );
BOOST_CHECK( boost::as_literal("hell") != rr );
BOOST_CHECK( ! (boost::as_literal("hello dude") < rr ) );
irange rrr = rr;
BOOST_CHECK( rrr == rr );
BOOST_CHECK( !( rrr != rr ) );
BOOST_CHECK( !( rrr < rr ) );
const irange cr = make_iterator_range( str );
const irange cr = boost::make_iterator_range( str );
BOOST_CHECK_EQUAL( cr.front(), 'h' );
BOOST_CHECK_EQUAL( cr.back(), 'd' );
BOOST_CHECK_EQUAL( cr[1], 'e' );
BOOST_CHECK_EQUAL( cr(1), 'e' );
rrr = make_iterator_range( str, 1, -1 );
BOOST_CHECK( rrr == as_literal("ello worl") );
rrr = make_iterator_range( rrr, -1, 1 );
rrr = boost::make_iterator_range( str, 1, -1 );
BOOST_CHECK( rrr == boost::as_literal("ello worl") );
rrr = boost::make_iterator_range( rrr, -1, 1 );
BOOST_CHECK( rrr == str );
rrr.front() = 'H';
rrr.back() = 'D';
rrr[1] = 'E';
BOOST_CHECK( rrr == as_literal("HEllo worlD") );
BOOST_CHECK( rrr == boost::as_literal("HEllo worlD") );
}
#include <boost/test/unit_test.hpp>
using boost::unit_test::test_suite;
test_suite* init_unit_test_suite( int argc, char* argv[] )
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
boost::unit_test::test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
test->add( BOOST_TEST_CASE( &check_sub_range ) );