Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r61035 - in trunk/boost/range: . algorithm algorithm_ext
From: neil_at_[hidden]
Date: 2010-04-04 06:47:29

Author: neilgroves
Date: 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
New Revision: 61035
URL: http://svn.boost.org/trac/boost/changeset/61035

Log:
Boost.Range is modified to conditionally compile concept assertions. This has been configured to disable concept assertions in Boost.Range for known broken compilers.
Text files modified:
   trunk/boost/range/algorithm/adjacent_find.hpp | 22 +++++-----
   trunk/boost/range/algorithm/binary_search.hpp | 4 +-
   trunk/boost/range/algorithm/copy.hpp | 2
   trunk/boost/range/algorithm/copy_backward.hpp | 2
   trunk/boost/range/algorithm/count.hpp | 4 +-
   trunk/boost/range/algorithm/count_if.hpp | 4 +-
   trunk/boost/range/algorithm/equal.hpp | 8 ++--
   trunk/boost/range/algorithm/equal_range.hpp | 8 ++--
   trunk/boost/range/algorithm/fill.hpp | 2
   trunk/boost/range/algorithm/fill_n.hpp | 2
   trunk/boost/range/algorithm/find.hpp | 4 +-
   trunk/boost/range/algorithm/find_end.hpp | 16 ++++----
   trunk/boost/range/algorithm/find_first_of.hpp | 16 ++++----
   trunk/boost/range/algorithm/find_if.hpp | 4 +-
   trunk/boost/range/algorithm/for_each.hpp | 4 +-
   trunk/boost/range/algorithm/generate.hpp | 4 +-
   trunk/boost/range/algorithm/heap_algorithm.hpp | 32 ++++++++--------
   trunk/boost/range/algorithm/inplace_merge.hpp | 8 ++--
   trunk/boost/range/algorithm/lexicographical_compare.hpp | 8 ++--
   trunk/boost/range/algorithm/lower_bound.hpp | 8 ++--
   trunk/boost/range/algorithm/max_element.hpp | 16 ++++----
   trunk/boost/range/algorithm/merge.hpp | 8 ++--
   trunk/boost/range/algorithm/min_element.hpp | 16 ++++----
   trunk/boost/range/algorithm/mismatch.hpp | 32 ++++++++--------
   trunk/boost/range/algorithm/nth_element.hpp | 8 ++--
   trunk/boost/range/algorithm/partial_sort.hpp | 8 ++--
   trunk/boost/range/algorithm/partial_sort_copy.hpp | 16 ++++----
   trunk/boost/range/algorithm/partition.hpp | 8 ++--
   trunk/boost/range/algorithm/permutation.hpp | 16 ++++----
   trunk/boost/range/algorithm/random_shuffle.hpp | 8 ++--
   trunk/boost/range/algorithm/remove.hpp | 8 ++--
   trunk/boost/range/algorithm/remove_copy.hpp | 2
   trunk/boost/range/algorithm/remove_if.hpp | 8 ++--
   trunk/boost/range/algorithm/replace.hpp | 4 +-
   trunk/boost/range/algorithm/replace_copy.hpp | 2
   trunk/boost/range/algorithm/replace_copy_if.hpp | 2
   trunk/boost/range/algorithm/replace_if.hpp | 4 +-
   trunk/boost/range/algorithm/reverse.hpp | 4 +-
   trunk/boost/range/algorithm/reverse_copy.hpp | 4 +-
   trunk/boost/range/algorithm/rotate.hpp | 4 +-
   trunk/boost/range/algorithm/rotate_copy.hpp | 2
   trunk/boost/range/algorithm/search.hpp | 32 ++++++++--------
   trunk/boost/range/algorithm/search_n.hpp | 24 ++++++------
   trunk/boost/range/algorithm/set_algorithm.hpp | 40 ++++++++++----------
   trunk/boost/range/algorithm/sort.hpp | 8 ++--
   trunk/boost/range/algorithm/stable_partition.hpp | 8 ++--
   trunk/boost/range/algorithm/stable_sort.hpp | 8 ++--
   trunk/boost/range/algorithm/swap_ranges.hpp | 4 +-
   trunk/boost/range/algorithm/transform.hpp | 6 +-
   trunk/boost/range/algorithm/unique.hpp | 16 ++++----
   trunk/boost/range/algorithm/unique_copy.hpp | 4 +-
   trunk/boost/range/algorithm/upper_bound.hpp | 8 ++--
   trunk/boost/range/algorithm_ext/is_sorted.hpp | 8 ++--
   trunk/boost/range/concepts.hpp | 80 +++++++++++++++++++++++++++++++++------
   trunk/boost/range/join.hpp | 8 ++--
   55 files changed, 325 insertions(+), 271 deletions(-)

Modified: trunk/boost/range/algorithm/adjacent_find.hpp
==============================================================================
--- trunk/boost/range/algorithm/adjacent_find.hpp (original)
+++ trunk/boost/range/algorithm/adjacent_find.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -32,7 +32,7 @@
inline typename range_iterator<ForwardRange>::type
adjacent_find(ForwardRange & rng)
{
- BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
     return std::adjacent_find(boost::begin(rng),boost::end(rng));
}

@@ -41,7 +41,7 @@
inline typename range_iterator<const ForwardRange>::type
adjacent_find(const ForwardRange& rng)
{
- BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
     return std::adjacent_find(boost::begin(rng),boost::end(rng));
}

@@ -50,8 +50,8 @@
inline typename range_iterator<ForwardRange>::type
adjacent_find(ForwardRange & rng, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
- BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
         typename range_value<ForwardRange>::type,
         typename range_value<ForwardRange>::type>));
     return std::adjacent_find(boost::begin(rng),boost::end(rng),pred);
@@ -62,8 +62,8 @@
inline typename range_iterator<const ForwardRange>::type
adjacent_find(const ForwardRange& rng, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
- BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
         typename range_value<const ForwardRange>::type,
         typename range_value<const ForwardRange>::type>));
     return std::adjacent_find(boost::begin(rng),boost::end(rng),pred);
@@ -76,7 +76,7 @@
inline typename range_return<ForwardRange,re>::type
adjacent_find(ForwardRange & rng)
{
- BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
     return range_return<ForwardRange,re>::
         pack(std::adjacent_find(boost::begin(rng),boost::end(rng)),
              rng);
@@ -87,7 +87,7 @@
inline typename range_return<const ForwardRange,re>::type
adjacent_find(const ForwardRange& rng)
{
- BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
     return range_return<const ForwardRange,re>::
         pack(std::adjacent_find(boost::begin(rng),boost::end(rng)),
              rng);
@@ -98,8 +98,8 @@
inline typename range_return<ForwardRange,re>::type
adjacent_find(ForwardRange& rng, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
- BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
         typename range_value<ForwardRange>::type,
         typename range_value<ForwardRange>::type>));
     return range_return<ForwardRange,re>::
@@ -112,7 +112,7 @@
inline typename range_return<const ForwardRange,re>::type
adjacent_find(const ForwardRange& rng, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
     return range_return<const ForwardRange,re>::
         pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred),
              rng);

Modified: trunk/boost/range/algorithm/binary_search.hpp
==============================================================================
--- trunk/boost/range/algorithm/binary_search.hpp (original)
+++ trunk/boost/range/algorithm/binary_search.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -29,7 +29,7 @@
template<class ForwardRange, class Value>
inline bool binary_search(const ForwardRange& rng, const Value& val)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return std::binary_search(boost::begin(rng), boost::end(rng), val);
}

@@ -38,7 +38,7 @@
inline bool binary_search(const ForwardRange& rng, const Value& val,
                           BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return std::binary_search(boost::begin(rng), boost::end(rng), val, pred);
}

Modified: trunk/boost/range/algorithm/copy.hpp
==============================================================================
--- trunk/boost/range/algorithm/copy.hpp (original)
+++ trunk/boost/range/algorithm/copy.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -30,7 +30,7 @@
template< class SinglePassRange, class OutputIterator >
inline OutputIterator copy(const SinglePassRange& rng, OutputIterator out)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::copy(boost::begin(rng),boost::end(rng),out);
}

Modified: trunk/boost/range/algorithm/copy_backward.hpp
==============================================================================
--- trunk/boost/range/algorithm/copy_backward.hpp (original)
+++ trunk/boost/range/algorithm/copy_backward.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -32,7 +32,7 @@
copy_backward(const BidirectionalRange& rng,
BidirectionalTraversalWriteableIterator out)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::copy_backward(boost::begin(rng), boost::end(rng), out);
}

Modified: trunk/boost/range/algorithm/count.hpp
==============================================================================
--- trunk/boost/range/algorithm/count.hpp (original)
+++ trunk/boost/range/algorithm/count.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -30,7 +30,7 @@
inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange>::type
count(SinglePassRange& rng, const Value& val)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::count(boost::begin(rng), boost::end(rng), val);
}

@@ -39,7 +39,7 @@
inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange const>::type
count(const SinglePassRange& rng, const Value& val)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::count(boost::begin(rng), boost::end(rng), val);
}

Modified: trunk/boost/range/algorithm/count_if.hpp
==============================================================================
--- trunk/boost/range/algorithm/count_if.hpp (original)
+++ trunk/boost/range/algorithm/count_if.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -31,7 +31,7 @@
inline BOOST_DEDUCED_TYPENAME boost::range_difference<SinglePassRange>::type
count_if(SinglePassRange& rng, UnaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::count_if(boost::begin(rng), boost::end(rng), pred);
}

@@ -40,7 +40,7 @@
inline BOOST_DEDUCED_TYPENAME boost::range_difference<const SinglePassRange>::type
count_if(const SinglePassRange& rng, UnaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::count_if(boost::begin(rng), boost::end(rng), pred);
}

Modified: trunk/boost/range/algorithm/equal.hpp
==============================================================================
--- trunk/boost/range/algorithm/equal.hpp (original)
+++ trunk/boost/range/algorithm/equal.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -159,8 +159,8 @@
         template< class SinglePassRange1, class SinglePassRange2 >
         inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2 )
         {
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));

             return ::boost::range_detail::equal(
                 ::boost::begin(rng1), ::boost::end(rng1),
@@ -172,8 +172,8 @@
         inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
                            BinaryPredicate pred )
         {
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));

             return ::boost::range_detail::equal(
                 ::boost::begin(rng1), ::boost::end(rng1),

Modified: trunk/boost/range/algorithm/equal_range.hpp
==============================================================================
--- trunk/boost/range/algorithm/equal_range.hpp (original)
+++ trunk/boost/range/algorithm/equal_range.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -33,7 +33,7 @@
>
equal_range(ForwardRange& rng, const Value& val)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::equal_range(boost::begin(rng), boost::end(rng), val);
}

@@ -45,7 +45,7 @@
>
equal_range(const ForwardRange& rng, const Value& val)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return std::equal_range(boost::begin(rng), boost::end(rng), val);
}

@@ -57,7 +57,7 @@
>
equal_range(ForwardRange& rng, const Value& val, SortPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::equal_range(boost::begin(rng), boost::end(rng), val, pred);
}

@@ -69,7 +69,7 @@
>
equal_range(const ForwardRange& rng, const Value& val, SortPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return std::equal_range(boost::begin(rng), boost::end(rng), val, pred);
}

Modified: trunk/boost/range/algorithm/fill.hpp
==============================================================================
--- trunk/boost/range/algorithm/fill.hpp (original)
+++ trunk/boost/range/algorithm/fill.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -28,7 +28,7 @@
template< class ForwardRange, class Value >
inline ForwardRange& fill(ForwardRange& rng, const Value& val)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
std::fill(boost::begin(rng), boost::end(rng), val);
return rng;
}

Modified: trunk/boost/range/algorithm/fill_n.hpp
==============================================================================
--- trunk/boost/range/algorithm/fill_n.hpp (original)
+++ trunk/boost/range/algorithm/fill_n.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -29,7 +29,7 @@
template< class ForwardRange, class Size, class Value >
inline ForwardRange& fill_n(ForwardRange& rng, Size n, const Value& val)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     BOOST_ASSERT( static_cast<Size>(std::distance(boost::begin(rng), boost::end(rng))) >= n );
     std::fill_n(boost::begin(rng), n, val);
     return rng;

Modified: trunk/boost/range/algorithm/find.hpp
==============================================================================
--- trunk/boost/range/algorithm/find.hpp (original)
+++ trunk/boost/range/algorithm/find.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -30,7 +30,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
find( SinglePassRange& rng, const Value& val )
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
     return std::find(boost::begin(rng), boost::end(rng), val);
}

@@ -41,7 +41,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
find( SinglePassRange& rng, const Value& val )
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
     return range_return<SinglePassRange,re>::
         pack(std::find(boost::begin(rng), boost::end(rng), val),
              rng);

Modified: trunk/boost/range/algorithm/find_end.hpp
==============================================================================
--- trunk/boost/range/algorithm/find_end.hpp (original)
+++ trunk/boost/range/algorithm/find_end.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -32,8 +32,8 @@
inline BOOST_DEDUCED_TYPENAME range_iterator< ForwardRange1 >::type
find_end(ForwardRange1 & rng1, const ForwardRange2& rng2)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));

     return std::find_end(boost::begin(rng1),boost::end(rng1),
                          boost::begin(rng2),boost::end(rng2));
@@ -44,8 +44,8 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
find_end(ForwardRange1 & rng1, const ForwardRange2& rng2, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));

     return std::find_end(boost::begin(rng1),boost::end(rng1),
                          boost::begin(rng2),boost::end(rng2),pred);
@@ -56,8 +56,8 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
find_end(ForwardRange1& rng1, const ForwardRange2& rng2)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));

     return range_return<ForwardRange1,re>::
         pack(std::find_end(boost::begin(rng1), boost::end(rng1),
@@ -71,8 +71,8 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
find_end(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));

     return range_return<ForwardRange1,re>::
         pack(std::find_end(boost::begin(rng1), boost::end(rng1),

Modified: trunk/boost/range/algorithm/find_first_of.hpp
==============================================================================
--- trunk/boost/range/algorithm/find_first_of.hpp (original)
+++ trunk/boost/range/algorithm/find_first_of.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -32,8 +32,8 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));

     return std::find_first_of(boost::begin(rng1),boost::end(rng1),
                               boost::begin(rng2),boost::end(rng2));
@@ -44,8 +44,8 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));

     return std::find_first_of(boost::begin(rng1),boost::end(rng1),
                               boost::begin(rng2),boost::end(rng2),pred);
@@ -57,8 +57,8 @@
inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type
find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));

     return range_return<SinglePassRange1,re>::
         pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
@@ -73,8 +73,8 @@
find_first_of(SinglePassRange1 & rng1, const ForwardRange2& rng2,
               BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));

     return range_return<SinglePassRange1,re>::
         pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),

Modified: trunk/boost/range/algorithm/find_if.hpp
==============================================================================
--- trunk/boost/range/algorithm/find_if.hpp (original)
+++ trunk/boost/range/algorithm/find_if.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -31,7 +31,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
find_if( SinglePassRange& rng, UnaryPredicate pred )
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
     return std::find_if(boost::begin(rng), boost::end(rng), pred);
}

@@ -42,7 +42,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
find_if( SinglePassRange& rng, UnaryPredicate pred )
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
     return range_return<SinglePassRange,re>::
         pack(std::find_if(boost::begin(rng), boost::end(rng), pred),
              rng);

Modified: trunk/boost/range/algorithm/for_each.hpp
==============================================================================
--- trunk/boost/range/algorithm/for_each.hpp (original)
+++ trunk/boost/range/algorithm/for_each.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -29,7 +29,7 @@
template< class SinglePassRange, class UnaryFunction >
inline UnaryFunction for_each(SinglePassRange & rng, UnaryFunction fun)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::for_each(boost::begin(rng),boost::end(rng),fun);
}

@@ -37,7 +37,7 @@
template< class SinglePassRange, class UnaryFunction >
inline UnaryFunction for_each(SinglePassRange const & rng, UnaryFunction fun)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::for_each(boost::begin(rng),boost::end(rng),fun);
}

Modified: trunk/boost/range/algorithm/generate.hpp
==============================================================================
--- trunk/boost/range/algorithm/generate.hpp (original)
+++ trunk/boost/range/algorithm/generate.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -28,7 +28,7 @@
template< class ForwardRange, class Generator >
inline ForwardRange& generate( ForwardRange& rng, Generator gen )
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     std::generate(boost::begin(rng), boost::end(rng), gen);
     return rng;
}
@@ -37,7 +37,7 @@
template< class ForwardRange, class Generator >
inline const ForwardRange& generate(const ForwardRange& rng, Generator gen)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     std::generate(boost::begin(rng), boost::end(rng), gen);
     return rng;
}

Modified: trunk/boost/range/algorithm/heap_algorithm.hpp
==============================================================================
--- trunk/boost/range/algorithm/heap_algorithm.hpp (original)
+++ trunk/boost/range/algorithm/heap_algorithm.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -29,7 +29,7 @@
template<class RandomAccessRange>
inline void push_heap(RandomAccessRange& rng)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::push_heap(boost::begin(rng), boost::end(rng));
}

@@ -37,7 +37,7 @@
template<class RandomAccessRange>
inline void push_heap(const RandomAccessRange& rng)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
     std::push_heap(boost::begin(rng), boost::end(rng));
}

@@ -45,7 +45,7 @@
template<class RandomAccessRange, class Compare>
inline void push_heap(RandomAccessRange& rng, Compare comp_pred)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
}

@@ -53,7 +53,7 @@
template<class RandomAccessRange, class Compare>
inline void push_heap(const RandomAccessRange& rng, Compare comp_pred)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
     std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
}

@@ -66,7 +66,7 @@
template<class RandomAccessRange>
inline void pop_heap(RandomAccessRange& rng)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::pop_heap(boost::begin(rng), boost::end(rng));
}

@@ -74,7 +74,7 @@
template<class RandomAccessRange>
inline void pop_heap(const RandomAccessRange& rng)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
     std::pop_heap(boost::begin(rng),boost::end(rng));
}

@@ -82,7 +82,7 @@
template<class RandomAccessRange, class Compare>
inline void pop_heap(RandomAccessRange& rng, Compare comp_pred)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
}

@@ -90,7 +90,7 @@
template<class RandomAccessRange, class Compare>
inline void pop_heap(const RandomAccessRange& rng, Compare comp_pred)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
     std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
}

@@ -103,7 +103,7 @@
template<class RandomAccessRange>
inline void make_heap(RandomAccessRange& rng)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::make_heap(boost::begin(rng), boost::end(rng));
}

@@ -111,7 +111,7 @@
template<class RandomAccessRange>
inline void make_heap(const RandomAccessRange& rng)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
     std::make_heap(boost::begin(rng),boost::end(rng));
}

@@ -119,7 +119,7 @@
template<class RandomAccessRange, class Compare>
inline void make_heap(RandomAccessRange& rng, Compare comp_pred)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
}

@@ -127,7 +127,7 @@
template<class RandomAccessRange, class Compare>
inline void make_heap(const RandomAccessRange& rng, Compare comp_pred)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
     std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
}

@@ -140,7 +140,7 @@
template<class RandomAccessRange>
inline void sort_heap(RandomAccessRange& rng)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::sort_heap(boost::begin(rng), boost::end(rng));
}

@@ -148,7 +148,7 @@
template<class RandomAccessRange>
inline void sort_heap(const RandomAccessRange& rng)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
     std::sort_heap(boost::begin(rng), boost::end(rng));
}

@@ -156,7 +156,7 @@
template<class RandomAccessRange, class Compare>
inline void sort_heap(RandomAccessRange& rng, Compare comp_pred)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
}

@@ -164,7 +164,7 @@
template<class RandomAccessRange, class Compare>
inline void sort_heap(const RandomAccessRange& rng, Compare comp_pred)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
     std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
}

Modified: trunk/boost/range/algorithm/inplace_merge.hpp
==============================================================================
--- trunk/boost/range/algorithm/inplace_merge.hpp (original)
+++ trunk/boost/range/algorithm/inplace_merge.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -30,7 +30,7 @@
inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
     BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type middle)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
     std::inplace_merge(boost::begin(rng), middle, boost::end(rng));
     return rng;
}
@@ -40,7 +40,7 @@
inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng,
     BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
     std::inplace_merge(boost::begin(rng), middle, boost::end(rng));
     return rng;
}
@@ -51,7 +51,7 @@
     BOOST_DEDUCED_TYPENAME boost::range_iterator<BidirectionalRange>::type middle,
     BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
     std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred);
     return rng;
}
@@ -62,7 +62,7 @@
     BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle,
     BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
     std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred);
     return rng;
}

Modified: trunk/boost/range/algorithm/lexicographical_compare.hpp
==============================================================================
--- trunk/boost/range/algorithm/lexicographical_compare.hpp (original)
+++ trunk/boost/range/algorithm/lexicographical_compare.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -30,8 +30,8 @@
inline bool lexicographical_compare(const SinglePassRange1& rng1,
                                     const SinglePassRange2& rng2)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
     return std::lexicographical_compare(
         boost::begin(rng1), boost::end(rng1),
         boost::begin(rng2), boost::end(rng2));
@@ -44,8 +44,8 @@
                                     const SinglePassRange2& rng2,
                                     BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
     return std::lexicographical_compare(
         boost::begin(rng1), boost::end(rng1),
         boost::begin(rng2), boost::end(rng2), pred);

Modified: trunk/boost/range/algorithm/lower_bound.hpp
==============================================================================
--- trunk/boost/range/algorithm/lower_bound.hpp (original)
+++ trunk/boost/range/algorithm/lower_bound.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -30,7 +30,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
lower_bound( ForwardRange& rng, Value val )
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::lower_bound(boost::begin(rng), boost::end(rng), val);
}
/// \overload
@@ -38,7 +38,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred);
}
/// \overload
@@ -46,7 +46,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
lower_bound( ForwardRange& rng, Value val )
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return range_return<ForwardRange,re>::
         pack(std::lower_bound(boost::begin(rng), boost::end(rng), val),
              rng);
@@ -56,7 +56,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return range_return<ForwardRange,re>::
         pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred),
              rng);

Modified: trunk/boost/range/algorithm/max_element.hpp
==============================================================================
--- trunk/boost/range/algorithm/max_element.hpp (original)
+++ trunk/boost/range/algorithm/max_element.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -31,7 +31,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
max_element(ForwardRange& rng)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::max_element(boost::begin(rng), boost::end(rng));
}

@@ -40,7 +40,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
max_element(const ForwardRange& rng)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return std::max_element(boost::begin(rng), boost::end(rng));
}

@@ -49,7 +49,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
max_element(ForwardRange& rng, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::max_element(boost::begin(rng), boost::end(rng), pred);
}

@@ -58,7 +58,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
max_element(const ForwardRange& rng, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return std::max_element(boost::begin(rng), boost::end(rng), pred);
}

@@ -69,7 +69,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
max_element(ForwardRange& rng)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return range_return<ForwardRange,re>::pack(
         std::max_element(boost::begin(rng), boost::end(rng)),
         rng);
@@ -80,7 +80,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
max_element(const ForwardRange& rng)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return range_return<const ForwardRange,re>::pack(
         std::max_element(boost::begin(rng), boost::end(rng)),
         rng);
@@ -91,7 +91,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
max_element(ForwardRange& rng, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return range_return<ForwardRange,re>::pack(
         std::max_element(boost::begin(rng), boost::end(rng), pred),
         rng);
@@ -102,7 +102,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
max_element(const ForwardRange& rng, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return range_return<const ForwardRange,re>::pack(
         std::max_element(boost::begin(rng), boost::end(rng), pred),
         rng);

Modified: trunk/boost/range/algorithm/merge.hpp
==============================================================================
--- trunk/boost/range/algorithm/merge.hpp (original)
+++ trunk/boost/range/algorithm/merge.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -34,8 +34,8 @@
                             const SinglePassRange2& rng2,
                             OutputIterator out)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
     return std::merge(boost::begin(rng1), boost::end(rng1),
                       boost::begin(rng2), boost::end(rng2), out);
}
@@ -48,8 +48,8 @@
                             OutputIterator out,
                             BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
     return std::merge(boost::begin(rng1), boost::end(rng1),
                       boost::begin(rng2), boost::end(rng2), out, pred);
}

Modified: trunk/boost/range/algorithm/min_element.hpp
==============================================================================
--- trunk/boost/range/algorithm/min_element.hpp (original)
+++ trunk/boost/range/algorithm/min_element.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -31,7 +31,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
min_element(ForwardRange& rng)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::min_element(boost::begin(rng), boost::end(rng));
}

@@ -40,7 +40,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
min_element(const ForwardRange& rng)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return std::min_element(boost::begin(rng), boost::end(rng));
}

@@ -49,7 +49,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
min_element(ForwardRange& rng, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::min_element(boost::begin(rng), boost::end(rng), pred);
}

@@ -58,7 +58,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
min_element(const ForwardRange& rng, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return std::min_element(boost::begin(rng), boost::end(rng), pred);
}

@@ -69,7 +69,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
min_element(ForwardRange& rng)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return range_return<ForwardRange,re>::pack(
         std::min_element(boost::begin(rng), boost::end(rng)),
         rng);
@@ -80,7 +80,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
min_element(const ForwardRange& rng)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return range_return<const ForwardRange,re>::pack(
         std::min_element(boost::begin(rng), boost::end(rng)),
         rng);
@@ -91,7 +91,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
min_element(ForwardRange& rng, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return range_return<ForwardRange,re>::pack(
         std::min_element(boost::begin(rng), boost::end(rng), pred),
         rng);
@@ -102,7 +102,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
min_element(const ForwardRange& rng, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return range_return<const ForwardRange,re>::pack(
         std::min_element(boost::begin(rng), boost::end(rng), pred),
         rng);

Modified: trunk/boost/range/algorithm/mismatch.hpp
==============================================================================
--- trunk/boost/range/algorithm/mismatch.hpp (original)
+++ trunk/boost/range/algorithm/mismatch.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -74,8 +74,8 @@
     BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, const SinglePassRange2 & rng2)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));

     return ::boost::range_detail::mismatch_impl(
         ::boost::begin(rng1), ::boost::end(rng1),
@@ -89,8 +89,8 @@
     BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));

     return ::boost::range_detail::mismatch_impl(
         ::boost::begin(rng1), ::boost::end(rng1),
@@ -104,8 +104,8 @@
     BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, SinglePassRange2 & rng2)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));

     return ::boost::range_detail::mismatch_impl(
         ::boost::begin(rng1), ::boost::end(rng1),
@@ -119,8 +119,8 @@
     BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));

     return ::boost::range_detail::mismatch_impl(
         ::boost::begin(rng1), ::boost::end(rng1),
@@ -135,8 +135,8 @@
     BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));

     return ::boost::range_detail::mismatch_impl(
         ::boost::begin(rng1), ::boost::end(rng1),
@@ -150,8 +150,8 @@
     BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));

     return ::boost::range_detail::mismatch_impl(
         ::boost::begin(rng1), ::boost::end(rng1),
@@ -165,8 +165,8 @@
     BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));

     return ::boost::range_detail::mismatch_impl(
         ::boost::begin(rng1), ::boost::end(rng1),
@@ -180,8 +180,8 @@
     BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));

     return ::boost::range_detail::mismatch_impl(
         ::boost::begin(rng1), ::boost::end(rng1),

Modified: trunk/boost/range/algorithm/nth_element.hpp
==============================================================================
--- trunk/boost/range/algorithm/nth_element.hpp (original)
+++ trunk/boost/range/algorithm/nth_element.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -30,7 +30,7 @@
inline void nth_element(RandomAccessRange& rng,
     BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::nth_element(boost::begin(rng), nth, boost::end(rng));
}

@@ -39,7 +39,7 @@
inline void nth_element(const RandomAccessRange& rng,
     BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
     std::nth_element(boost::begin(rng),nth,boost::end(rng));
}

@@ -49,7 +49,7 @@
     BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth,
     BinaryPredicate sort_pred)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::nth_element(boost::begin(rng), nth, boost::end(rng), sort_pred);
}

@@ -59,7 +59,7 @@
     BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth,
     BinaryPredicate sort_pred)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
     std::nth_element(boost::begin(rng),nth,boost::end(rng), sort_pred);
}

Modified: trunk/boost/range/algorithm/partial_sort.hpp
==============================================================================
--- trunk/boost/range/algorithm/partial_sort.hpp (original)
+++ trunk/boost/range/algorithm/partial_sort.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -30,7 +30,7 @@
inline void partial_sort(RandomAccessRange& rng,
     BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::partial_sort(boost::begin(rng), middle, boost::end(rng));
}

@@ -39,7 +39,7 @@
inline void partial_sort(const RandomAccessRange& rng,
     BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
     std::partial_sort(boost::begin(rng), middle, boost::end(rng));
}

@@ -49,7 +49,7 @@
     BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle,
     BinaryPredicate sort_pred)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::partial_sort(boost::begin(rng), middle, boost::end(rng),
                         sort_pred);
}
@@ -60,7 +60,7 @@
     BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle,
     BinaryPredicate sort_pred)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
     std::partial_sort(boost::begin(rng), middle, boost::end(rng), sort_pred);
}

Modified: trunk/boost/range/algorithm/partial_sort_copy.hpp
==============================================================================
--- trunk/boost/range/algorithm/partial_sort_copy.hpp (original)
+++ trunk/boost/range/algorithm/partial_sort_copy.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -32,10 +32,10 @@
inline typename range_iterator<RandomAccessRange>::type
partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2)
{
- BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
- BOOST_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept<RandomAccessRange>));
- BOOST_CONCEPT_ASSERT((range_detail::SameTypeConcept<typename range_value<SinglePassRange>::type, typename range_value<RandomAccessRange>::type>));
- BOOST_CONCEPT_ASSERT((LessThanComparableConcept<typename range_value<SinglePassRange>::type>));
+ BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept<RandomAccessRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((range_detail::SameTypeConcept<typename range_value<SinglePassRange>::type, typename range_value<RandomAccessRange>::type>));
+ BOOST_RANGE_CONCEPT_ASSERT((LessThanComparableConcept<typename range_value<SinglePassRange>::type>));

     return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
         boost::begin(rng2), boost::end(rng2));
@@ -48,10 +48,10 @@
partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2,
     BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
- BOOST_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept<RandomAccessRange>));
- BOOST_CONCEPT_ASSERT((range_detail::SameTypeConcept<typename range_value<SinglePassRange>::type, typename range_value<RandomAccessRange>::type>));
- BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, typename range_value<RandomAccessRange>::type, typename range_value<RandomAccessRange>::type>));
+ BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept<RandomAccessRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((range_detail::SameTypeConcept<typename range_value<SinglePassRange>::type, typename range_value<RandomAccessRange>::type>));
+ BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, typename range_value<RandomAccessRange>::type, typename range_value<RandomAccessRange>::type>));

     return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
         boost::begin(rng2), boost::end(rng2), pred);

Modified: trunk/boost/range/algorithm/partition.hpp
==============================================================================
--- trunk/boost/range/algorithm/partition.hpp (original)
+++ trunk/boost/range/algorithm/partition.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -30,7 +30,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
partition(ForwardRange& rng, UnaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::partition(boost::begin(rng),boost::end(rng),pred);
}

@@ -39,7 +39,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
partition(const ForwardRange& rng, UnaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return std::partition(boost::begin(rng),boost::end(rng),pred);
}

@@ -51,7 +51,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
partition(ForwardRange& rng, UnaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return boost::range_return<ForwardRange,re>::
         pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
}
@@ -62,7 +62,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
partition(const ForwardRange& rng, UnaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return boost::range_return<const ForwardRange,re>::
         pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
}

Modified: trunk/boost/range/algorithm/permutation.hpp
==============================================================================
--- trunk/boost/range/algorithm/permutation.hpp (original)
+++ trunk/boost/range/algorithm/permutation.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -29,7 +29,7 @@
template<class BidirectionalRange>
inline bool next_permutation(BidirectionalRange& rng)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
     return std::next_permutation(boost::begin(rng), boost::end(rng));
}

@@ -37,7 +37,7 @@
template<class BidirectionalRange>
inline bool next_permutation(const BidirectionalRange& rng)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
     return std::next_permutation(boost::begin(rng), boost::end(rng));
}

@@ -45,7 +45,7 @@
template<class BidirectionalRange, class Compare>
inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
     return std::next_permutation(boost::begin(rng), boost::end(rng),
                                  comp_pred);
}
@@ -55,7 +55,7 @@
inline bool next_permutation(const BidirectionalRange& rng,
                              Compare comp_pred)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
     return std::next_permutation(boost::begin(rng), boost::end(rng),
                                  comp_pred);
}
@@ -69,7 +69,7 @@
template<class BidirectionalRange>
inline bool prev_permutation(BidirectionalRange& rng)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
     return std::prev_permutation(boost::begin(rng), boost::end(rng));
}

@@ -77,7 +77,7 @@
template<class BidirectionalRange>
inline bool prev_permutation(const BidirectionalRange& rng)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
     return std::prev_permutation(boost::begin(rng), boost::end(rng));
}

@@ -85,7 +85,7 @@
template<class BidirectionalRange, class Compare>
inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
     return std::prev_permutation(boost::begin(rng), boost::end(rng),
                                  comp_pred);
}
@@ -95,7 +95,7 @@
inline bool prev_permutation(const BidirectionalRange& rng,
                              Compare comp_pred)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
     return std::prev_permutation(boost::begin(rng), boost::end(rng),
                                  comp_pred);
}

Modified: trunk/boost/range/algorithm/random_shuffle.hpp
==============================================================================
--- trunk/boost/range/algorithm/random_shuffle.hpp (original)
+++ trunk/boost/range/algorithm/random_shuffle.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -29,7 +29,7 @@
template<class RandomAccessRange>
inline RandomAccessRange& random_shuffle(RandomAccessRange& rng)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::random_shuffle(boost::begin(rng), boost::end(rng));
     return rng;
}
@@ -38,7 +38,7 @@
template<class RandomAccessRange>
inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
     std::random_shuffle(boost::begin(rng),boost::end(rng));
     return rng;
}
@@ -47,7 +47,7 @@
template<class RandomAccessRange, class Generator>
inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
     return rng;
}
@@ -56,7 +56,7 @@
template<class RandomAccessRange, class Generator>
inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng, Generator& gen)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
     std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
     return rng;
}

Modified: trunk/boost/range/algorithm/remove.hpp
==============================================================================
--- trunk/boost/range/algorithm/remove.hpp (original)
+++ trunk/boost/range/algorithm/remove.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -30,7 +30,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
remove(ForwardRange& rng, const Value& val)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::remove(boost::begin(rng),boost::end(rng),val);
}

@@ -39,7 +39,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
remove(const ForwardRange& rng, const Value& val)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return std::remove(boost::begin(rng),boost::end(rng),val);
}

@@ -50,7 +50,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
remove(ForwardRange& rng, const Value& val)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return range_return<ForwardRange,re>::pack(
         std::remove(boost::begin(rng), boost::end(rng), val),
         rng);
@@ -61,7 +61,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
remove(const ForwardRange& rng, const Value& val)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return range_return<const ForwardRange,re>::pack(
         std::remove(boost::begin(rng), boost::end(rng), val),
         rng);

Modified: trunk/boost/range/algorithm/remove_copy.hpp
==============================================================================
--- trunk/boost/range/algorithm/remove_copy.hpp (original)
+++ trunk/boost/range/algorithm/remove_copy.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -33,7 +33,7 @@
inline OutputIterator
remove_copy(SinglePassRange& rng, OutputIterator out_it, const Value& val)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::remove_copy(boost::begin(rng), boost::end(rng), out_it, val);
}

Modified: trunk/boost/range/algorithm/remove_if.hpp
==============================================================================
--- trunk/boost/range/algorithm/remove_if.hpp (original)
+++ trunk/boost/range/algorithm/remove_if.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -31,7 +31,7 @@
inline BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type
remove_if(ForwardRange& rng, UnaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::remove_if(boost::begin(rng), boost::end(rng), pred);
}

@@ -40,7 +40,7 @@
inline BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
remove_if(const ForwardRange& rng, UnaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return std::remove_if(boost::begin(rng),boost::end(rng),pred);
}

@@ -51,7 +51,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
remove_if(ForwardRange& rng, UnaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return range_return<ForwardRange,re>::pack(
         std::remove_if(boost::begin(rng), boost::end(rng), pred),
         rng);
@@ -62,7 +62,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
remove_if(const ForwardRange& rng, UnaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return range_return<const ForwardRange,re>::pack(
         std::remove_if(boost::begin(rng), boost::end(rng), pred),
         rng);

Modified: trunk/boost/range/algorithm/replace.hpp
==============================================================================
--- trunk/boost/range/algorithm/replace.hpp (original)
+++ trunk/boost/range/algorithm/replace.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -30,7 +30,7 @@
replace(ForwardRange& rng, const Value& what,
         const Value& with_what)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     std::replace(boost::begin(rng), boost::end(rng), what, with_what);
     return rng;
}
@@ -41,7 +41,7 @@
replace(const ForwardRange& rng, const Value& what,
         const Value& with_what)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     std::replace(boost::begin(rng), boost::end(rng), what, with_what);
     return rng;
}

Modified: trunk/boost/range/algorithm/replace_copy.hpp
==============================================================================
--- trunk/boost/range/algorithm/replace_copy.hpp (original)
+++ trunk/boost/range/algorithm/replace_copy.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -30,7 +30,7 @@
replace_copy(ForwardRange& rng, OutputIterator out_it, const Value& what,
         const Value& with_what)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::replace_copy(boost::begin(rng), boost::end(rng), out_it,
         what, with_what);
}

Modified: trunk/boost/range/algorithm/replace_copy_if.hpp
==============================================================================
--- trunk/boost/range/algorithm/replace_copy_if.hpp (original)
+++ trunk/boost/range/algorithm/replace_copy_if.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -34,7 +34,7 @@
replace_copy_if(ForwardRange& rng, OutputIterator out_it, Predicate pred,
         const Value& with_what)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::replace_copy_if(boost::begin(rng), boost::end(rng), out_it,
         pred, with_what);
}

Modified: trunk/boost/range/algorithm/replace_if.hpp
==============================================================================
--- trunk/boost/range/algorithm/replace_if.hpp (original)
+++ trunk/boost/range/algorithm/replace_if.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -31,7 +31,7 @@
     replace_if(ForwardRange& rng, UnaryPredicate pred,
                const Value& val)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     std::replace_if(boost::begin(rng), boost::end(rng), pred, val);
     return rng;
}
@@ -42,7 +42,7 @@
     replace_if(const ForwardRange& rng, UnaryPredicate pred,
                const Value& val)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     std::replace_if(boost::begin(rng), boost::end(rng), pred, val);
     return rng;
}

Modified: trunk/boost/range/algorithm/reverse.hpp
==============================================================================
--- trunk/boost/range/algorithm/reverse.hpp (original)
+++ trunk/boost/range/algorithm/reverse.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -29,7 +29,7 @@
template<class BidirectionalRange>
inline BidirectionalRange& reverse(BidirectionalRange& rng)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
     std::reverse(boost::begin(rng), boost::end(rng));
     return rng;
}
@@ -38,7 +38,7 @@
template<class BidirectionalRange>
inline const BidirectionalRange& reverse(const BidirectionalRange& rng)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
     std::reverse(boost::begin(rng), boost::end(rng));
     return rng;
}

Modified: trunk/boost/range/algorithm/reverse_copy.hpp
==============================================================================
--- trunk/boost/range/algorithm/reverse_copy.hpp (original)
+++ trunk/boost/range/algorithm/reverse_copy.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -29,7 +29,7 @@
template<typename BidirectionalRange, typename OutputIterator>
inline OutputIterator reverse_copy(BidirectionalRange& rng, OutputIterator out)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::reverse_copy(boost::begin(rng), boost::end(rng), out);
}

@@ -37,7 +37,7 @@
template<typename BidirectionalRange, typename OutputIterator>
inline OutputIterator reverse_copy(const BidirectionalRange& rng, OutputIterator out)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::reverse_copy(boost::begin(rng), boost::end(rng), out);
}

Modified: trunk/boost/range/algorithm/rotate.hpp
==============================================================================
--- trunk/boost/range/algorithm/rotate.hpp (original)
+++ trunk/boost/range/algorithm/rotate.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -29,7 +29,7 @@
inline ForwardRange& rotate(ForwardRange& rng,
     typename range_iterator<ForwardRange>::type middle)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     std::rotate(boost::begin(rng), middle, boost::end(rng));
     return rng;
}
@@ -40,7 +40,7 @@
     rotate(const ForwardRange& rng,
            typename range_iterator<const ForwardRange>::type middle)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     std::rotate(boost::begin(rng), middle, boost::end(rng));
     return rng;
}

Modified: trunk/boost/range/algorithm/rotate_copy.hpp
==============================================================================
--- trunk/boost/range/algorithm/rotate_copy.hpp (original)
+++ trunk/boost/range/algorithm/rotate_copy.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -33,7 +33,7 @@
         OutputIterator target
         )
     {
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
         return std::rotate_copy(boost::begin(rng), middle, boost::end(rng), target);
     }

Modified: trunk/boost/range/algorithm/search.hpp
==============================================================================
--- trunk/boost/range/algorithm/search.hpp (original)
+++ trunk/boost/range/algorithm/search.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -32,8 +32,8 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
search(ForwardRange1& rng1, const ForwardRange2& rng2)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
     return std::search(boost::begin(rng1),boost::end(rng1),
                        boost::begin(rng2),boost::end(rng2));
}
@@ -43,8 +43,8 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
search(const ForwardRange1& rng1, const ForwardRange2& rng2)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
     return std::search(boost::begin(rng1),boost::end(rng1),
                        boost::begin(rng2),boost::end(rng2));
}
@@ -54,8 +54,8 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
     return std::search(boost::begin(rng1),boost::end(rng1),
                        boost::begin(rng2),boost::end(rng2),pred);
}
@@ -66,8 +66,8 @@
search(const ForwardRange1& rng1, const ForwardRange2& rng2,
         BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
     return std::search(boost::begin(rng1),boost::end(rng1),
                        boost::begin(rng2),boost::end(rng2),pred);
}
@@ -79,8 +79,8 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
search(ForwardRange1& rng1, const ForwardRange2& rng2)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
     return range_return<ForwardRange1,re>::
         pack(std::search(boost::begin(rng1),boost::end(rng1),
                          boost::begin(rng2),boost::end(rng2)),
@@ -92,8 +92,8 @@
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
search(const ForwardRange1& rng1, const ForwardRange2& rng2)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
     return range_return<const ForwardRange1,re>::
         pack(std::search(boost::begin(rng1),boost::end(rng1),
                          boost::begin(rng2),boost::end(rng2)),
@@ -106,8 +106,8 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
     return range_return<ForwardRange1,re>::
         pack(std::search(boost::begin(rng1),boost::end(rng1),
                          boost::begin(rng2),boost::end(rng2),pred),
@@ -121,8 +121,8 @@
search(const ForwardRange1& rng1, const ForwardRange2& rng2,
         BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
     return range_return<const ForwardRange1,re>::
         pack(std::search(boost::begin(rng1),boost::end(rng1),
                          boost::begin(rng2),boost::end(rng2),pred),

Modified: trunk/boost/range/algorithm/search_n.hpp
==============================================================================
--- trunk/boost/range/algorithm/search_n.hpp (original)
+++ trunk/boost/range/algorithm/search_n.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -35,7 +35,7 @@
inline typename range_iterator<ForwardRange>::type
search_n(ForwardRange& rng, Integer count, const Value& value)
{
- BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
     return std::search_n(boost::begin(rng),boost::end(rng), count, value);
}

@@ -44,7 +44,7 @@
inline typename range_iterator<const ForwardRange>::type
search_n(const ForwardRange& rng, Integer count, const Value& value)
{
- BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
     return std::search_n(boost::begin(rng), boost::end(rng), count, value);
}

@@ -55,8 +55,8 @@
search_n(ForwardRange& rng, Integer count, const Value& value,
          BinaryPredicate binary_pred)
{
- BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
- BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
         typename range_value<ForwardRange>::type, const Value&>));
     return std::search_n(boost::begin(rng), boost::end(rng),
         count, value, binary_pred);
@@ -69,8 +69,8 @@
search_n(const ForwardRange& rng, Integer count, const Value& value,
          BinaryPredicate binary_pred)
{
- BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
- BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
         typename range_value<const ForwardRange>::type, const Value&>));
     return std::search_n(boost::begin(rng), boost::end(rng),
         count, value, binary_pred);
@@ -84,7 +84,7 @@
inline typename range_return<ForwardRange,re>::type
search_n(ForwardRange& rng, Integer count, const Value& value)
{
- BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
     return range_return<ForwardRange,re>::
         pack(std::search_n(boost::begin(rng),boost::end(rng),
                            count, value),
@@ -97,7 +97,7 @@
inline typename range_return<const ForwardRange,re>::type
search_n(const ForwardRange& rng, Integer count, const Value& value)
{
- BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
     return range_return<const ForwardRange,re>::
         pack(std::search_n(boost::begin(rng), boost::end(rng),
                            count, value),
@@ -111,8 +111,8 @@
search_n(ForwardRange& rng, Integer count, const Value& value,
          BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
- BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
         typename range_value<ForwardRange>::type,
         const Value&>));
     return range_return<ForwardRange,re>::
@@ -128,8 +128,8 @@
search_n(const ForwardRange& rng, Integer count, const Value& value,
          BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
- BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
         typename range_value<const ForwardRange>::type,
         const Value&>));
     return range_return<const ForwardRange,re>::

Modified: trunk/boost/range/algorithm/set_algorithm.hpp
==============================================================================
--- trunk/boost/range/algorithm/set_algorithm.hpp (original)
+++ trunk/boost/range/algorithm/set_algorithm.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -31,8 +31,8 @@
inline bool includes(const SinglePassRange1& rng1,
                      const SinglePassRange2& rng2)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
     return std::includes(boost::begin(rng1),boost::end(rng1),
                          boost::begin(rng2),boost::end(rng2));
}
@@ -44,8 +44,8 @@
                      const SinglePassRange2& rng2,
                      BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
     return std::includes(boost::begin(rng1), boost::end(rng1),
                          boost::begin(rng2), boost::end(rng2), pred);
}
@@ -63,8 +63,8 @@
                                 const SinglePassRange2& rng2,
                                 OutputIterator out)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
     return std::set_union(boost::begin(rng1), boost::end(rng1),
                           boost::begin(rng2), boost::end(rng2), out);
}
@@ -77,8 +77,8 @@
                                 OutputIterator out,
                                 BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
     return std::set_union(boost::begin(rng1), boost::end(rng1),
                           boost::begin(rng2), boost::end(rng2), out, pred);
}
@@ -96,8 +96,8 @@
                                        const SinglePassRange2& rng2,
                                        OutputIterator out)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
     return std::set_intersection(boost::begin(rng1), boost::end(rng1),
                                  boost::begin(rng2), boost::end(rng2), out);
}
@@ -110,8 +110,8 @@
                                        OutputIterator out,
                                        BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
     return std::set_intersection(boost::begin(rng1), boost::end(rng1),
                                  boost::begin(rng2), boost::end(rng2),
                                  out, pred);
@@ -130,8 +130,8 @@
                                      const SinglePassRange2& rng2,
                                      OutputIterator out)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
     return std::set_difference(boost::begin(rng1), boost::end(rng1),
                                boost::begin(rng2), boost::end(rng2), out);
}
@@ -144,8 +144,8 @@
                                      OutputIterator out,
                                      BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
     return std::set_difference(
         boost::begin(rng1), boost::end(rng1),
         boost::begin(rng2), boost::end(rng2), out, pred);
@@ -165,8 +165,8 @@
                          const SinglePassRange2& rng2,
                          OutputIterator out)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
     return std::set_symmetric_difference(boost::begin(rng1), boost::end(rng1),
                                          boost::begin(rng2), boost::end(rng2), out);
}
@@ -180,8 +180,8 @@
                          OutputIterator out,
                          BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
     return std::set_symmetric_difference(
         boost::begin(rng1), boost::end(rng1),
         boost::begin(rng2), boost::end(rng2), out, pred);

Modified: trunk/boost/range/algorithm/sort.hpp
==============================================================================
--- trunk/boost/range/algorithm/sort.hpp (original)
+++ trunk/boost/range/algorithm/sort.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -29,7 +29,7 @@
template<class RandomAccessRange>
inline RandomAccessRange& sort(RandomAccessRange& rng)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::sort(boost::begin(rng), boost::end(rng));
     return rng;
}
@@ -38,7 +38,7 @@
template<class RandomAccessRange>
inline const RandomAccessRange& sort(const RandomAccessRange& rng)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
     std::sort(boost::begin(rng),boost::end(rng));
     return rng;
}
@@ -47,7 +47,7 @@
template<class RandomAccessRange, class BinaryPredicate>
inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::sort(boost::begin(rng), boost::end(rng), pred);
     return rng;
}
@@ -56,7 +56,7 @@
template<class RandomAccessRange, class BinaryPredicate>
inline const RandomAccessRange& sort(const RandomAccessRange& rng, BinaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
     std::sort(boost::begin(rng), boost::end(rng), pred);
     return rng;
}

Modified: trunk/boost/range/algorithm/stable_partition.hpp
==============================================================================
--- trunk/boost/range/algorithm/stable_partition.hpp (original)
+++ trunk/boost/range/algorithm/stable_partition.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -31,7 +31,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type
stable_partition(BidirectionalRange& rng, UnaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
     return std::stable_partition(boost::begin(rng), boost::end(rng), pred);
}

@@ -40,7 +40,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<const BidirectionalRange>::type
stable_partition(const BidirectionalRange& rng, UnaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
     return std::stable_partition(boost::begin(rng),boost::end(rng),pred);
}

@@ -49,7 +49,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<BidirectionalRange,re>::type
stable_partition(BidirectionalRange& rng, UnaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
     return range_return<BidirectionalRange,re>::pack(
         std::stable_partition(boost::begin(rng), boost::end(rng), pred),
         rng);
@@ -60,7 +60,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<const BidirectionalRange,re>::type
stable_partition(const BidirectionalRange& rng, UnaryPredicate pred)
{
- BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
     return range_return<const BidirectionalRange,re>::pack(
         std::stable_partition(boost::begin(rng),boost::end(rng),pred),
         rng);

Modified: trunk/boost/range/algorithm/stable_sort.hpp
==============================================================================
--- trunk/boost/range/algorithm/stable_sort.hpp (original)
+++ trunk/boost/range/algorithm/stable_sort.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -29,7 +29,7 @@
template<class RandomAccessRange>
inline RandomAccessRange& stable_sort(RandomAccessRange& rng)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::stable_sort(boost::begin(rng), boost::end(rng));
     return rng;
}
@@ -38,7 +38,7 @@
template<class RandomAccessRange>
inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
     std::stable_sort(boost::begin(rng), boost::end(rng));
     return rng;
}
@@ -47,7 +47,7 @@
template<class RandomAccessRange, class BinaryPredicate>
inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate sort_pred)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred);
     return rng;
}
@@ -56,7 +56,7 @@
template<class RandomAccessRange, class BinaryPredicate>
inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng, BinaryPredicate sort_pred)
{
- BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
     std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred);
     return rng;
}

Modified: trunk/boost/range/algorithm/swap_ranges.hpp
==============================================================================
--- trunk/boost/range/algorithm/swap_ranges.hpp (original)
+++ trunk/boost/range/algorithm/swap_ranges.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -70,8 +70,8 @@
inline SinglePassRange2&
swap_ranges(SinglePassRange1& range1, SinglePassRange2& range2)
{
- BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange1>));
- BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange2>));
+ BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange1>));
+ BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange2>));

boost::range_detail::swap_ranges_impl(
boost::begin(range1), boost::end(range1),

Modified: trunk/boost/range/algorithm/transform.hpp
==============================================================================
--- trunk/boost/range/algorithm/transform.hpp (original)
+++ trunk/boost/range/algorithm/transform.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -38,7 +38,7 @@
                   OutputIterator out,
                   UnaryOperation fun)
         {
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
             return std::transform(boost::begin(rng),boost::end(rng),out,fun);
         }

@@ -82,8 +82,8 @@
                   OutputIterator out,
                   BinaryOperation fun)
         {
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
             return range_detail::transform_impl(
                         boost::begin(rng1), boost::end(rng1),
                         boost::begin(rng2), boost::end(rng2),

Modified: trunk/boost/range/algorithm/unique.hpp
==============================================================================
--- trunk/boost/range/algorithm/unique.hpp (original)
+++ trunk/boost/range/algorithm/unique.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -30,7 +30,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
unique( ForwardRange& rng )
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return range_return<ForwardRange,re>::
         pack( std::unique( boost::begin(rng),
                            boost::end(rng)), rng );
@@ -41,7 +41,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
unique( const ForwardRange& rng )
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return range_return<const ForwardRange,re>::
         pack( std::unique( boost::begin(rng),
                            boost::end(rng)), rng );
@@ -51,7 +51,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
unique( ForwardRange& rng, BinaryPredicate pred )
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return range_return<ForwardRange,re>::
         pack(std::unique(boost::begin(rng), boost::end(rng), pred),
              rng);
@@ -61,7 +61,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
unique( const ForwardRange& rng, BinaryPredicate pred )
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return range_return<const ForwardRange,re>::
         pack(std::unique(boost::begin(rng), boost::end(rng), pred),
              rng);
@@ -72,7 +72,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type
unique( ForwardRange& rng )
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return ::boost::range::unique<return_begin_found>(rng);
}
/// \overload
@@ -80,7 +80,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange, return_begin_found>::type
unique( const ForwardRange& rng )
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return ::boost::range::unique<return_begin_found>(rng);
}
/// \overload
@@ -88,7 +88,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type
unique( ForwardRange& rng, BinaryPredicate pred )
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return ::boost::range::unique<return_begin_found>(rng);
}
/// \overload
@@ -96,7 +96,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
unique( const ForwardRange& rng, BinaryPredicate pred )
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return ::boost::range::unique<return_begin_found>(rng, pred);
}

Modified: trunk/boost/range/algorithm/unique_copy.hpp
==============================================================================
--- trunk/boost/range/algorithm/unique_copy.hpp (original)
+++ trunk/boost/range/algorithm/unique_copy.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -31,7 +31,7 @@
inline OutputIterator
unique_copy( const SinglePassRange& rng, OutputIterator out_it )
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
     return std::unique_copy(boost::begin(rng), boost::end(rng), out_it);
}
/// \overload
@@ -40,7 +40,7 @@
unique_copy( const SinglePassRange& rng, OutputIterator out_it,
              BinaryPredicate pred )
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
     return std::unique_copy(boost::begin(rng), boost::end(rng), out_it, pred);
}

Modified: trunk/boost/range/algorithm/upper_bound.hpp
==============================================================================
--- trunk/boost/range/algorithm/upper_bound.hpp (original)
+++ trunk/boost/range/algorithm/upper_bound.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -30,7 +30,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
upper_bound( ForwardRange& rng, Value val )
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::upper_bound(boost::begin(rng), boost::end(rng), val);
}
/// \overload
@@ -39,7 +39,7 @@
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred);
}
/// \overload
@@ -47,7 +47,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
upper_bound( ForwardRange& rng, Value val )
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return range_return<ForwardRange,re>::
         pack(std::upper_bound(boost::begin(rng), boost::end(rng), val),
              rng);
@@ -58,7 +58,7 @@
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
{
- BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return range_return<ForwardRange,re>::
         pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred),
              rng);

Modified: trunk/boost/range/algorithm_ext/is_sorted.hpp
==============================================================================
--- trunk/boost/range/algorithm_ext/is_sorted.hpp (original)
+++ trunk/boost/range/algorithm_ext/is_sorted.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -47,8 +47,8 @@
     template<typename SinglePassRange>
     inline bool is_sorted(const SinglePassRange& rng)
     {
- BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
- BOOST_CONCEPT_ASSERT((LessThanComparableConcept<typename range_value<SinglePassRange>::type>));
+ BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((LessThanComparableConcept<typename range_value<SinglePassRange>::type>));
         return range_detail::is_sorted(boost::begin(rng), boost::end(rng));
     }

@@ -56,8 +56,8 @@
     template<typename SinglePassRange, typename BinaryPredicate>
     inline bool is_sorted(const SinglePassRange& rng, BinaryPredicate pred)
     {
- BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
- BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, typename range_value<SinglePassRange>::type, typename range_value<SinglePassRange>::type>));
+ BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, typename range_value<SinglePassRange>::type, typename range_value<SinglePassRange>::type>));
         return range_detail::is_sorted(boost::begin(rng), boost::end(rng), pred);
     }
}

Modified: trunk/boost/range/concepts.hpp
==============================================================================
--- trunk/boost/range/concepts.hpp (original)
+++ trunk/boost/range/concepts.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -60,6 +60,40 @@

     namespace range_detail {

+#ifndef BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+
+// List broken compiler versions here:
+ #ifdef __GNUC__
+ // GNUC 4.2 has strange issues correctly detecting compliance with the Concepts
+ // hence the least disruptive approach is to turn-off the concept checking for
+ // this version of the compiler.
+ #if __GNUC__ == 4 && __GNUC_MINOR__ == 2
+ #define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
+ #endif
+ #endif
+
+ #ifdef __BORLANDC__
+ #define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
+ #endif
+
+ #ifdef __PATHCC__
+ #define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
+ #endif
+
+// Default to using the concept asserts unless we have defined it off
+// during the search for black listed compilers.
+ #ifndef BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ #define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 1
+ #endif
+
+#endif
+
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ #define BOOST_RANGE_CONCEPT_ASSERT( x ) BOOST_CONCEPT_ASSERT( x )
+#else
+ #define BOOST_RANGE_CONCEPT_ASSERT( x )
+#endif
+
         // Rationale for the inclusion of redefined iterator concept
         // classes:
         //
@@ -77,9 +111,10 @@
         template<class Iterator>
         struct IncrementableIteratorConcept : CopyConstructible<Iterator>
         {
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
             typedef BOOST_DEDUCED_TYPENAME iterator_traversal<Iterator>::type traversal_category;

- BOOST_CONCEPT_ASSERT((
+ BOOST_RANGE_CONCEPT_ASSERT((
                 Convertible<
                     traversal_category,
                     incrementable_traversal_tag
@@ -92,6 +127,7 @@
             }
         private:
             Iterator i;
+#endif
         };

         template<class Iterator>
@@ -99,11 +135,13 @@
             : IncrementableIteratorConcept<Iterator>
             , EqualityComparable<Iterator>
         {
- BOOST_CONCEPT_ASSERT((
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ BOOST_RANGE_CONCEPT_ASSERT((
                 Convertible<
                     BOOST_DEDUCED_TYPENAME SinglePassIteratorConcept::traversal_category,
                     single_pass_traversal_tag
>));
+#endif
         };

         template<class Iterator>
@@ -111,23 +149,26 @@
             : SinglePassIteratorConcept<Iterator>
             , DefaultConstructible<Iterator>
         {
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
             typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::difference_type difference_type;

             BOOST_MPL_ASSERT((is_integral<difference_type>));
             BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);

- BOOST_CONCEPT_ASSERT((
+ BOOST_RANGE_CONCEPT_ASSERT((
                 Convertible<
                     BOOST_DEDUCED_TYPENAME ForwardIteratorConcept::traversal_category,
                     forward_traversal_tag
>));
+#endif
          };

          template<class Iterator>
          struct BidirectionalIteratorConcept
              : ForwardIteratorConcept<Iterator>
          {
- BOOST_CONCEPT_ASSERT((
+ #if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ BOOST_RANGE_CONCEPT_ASSERT((
                  Convertible<
                      BOOST_DEDUCED_TYPENAME BidirectionalIteratorConcept::traversal_category,
                      bidirectional_traversal_tag
@@ -140,13 +181,15 @@
              }
          private:
              Iterator i;
+ #endif
          };

          template<class Iterator>
          struct RandomAccessIteratorConcept
              : BidirectionalIteratorConcept<Iterator>
          {
- BOOST_CONCEPT_ASSERT((
+ #if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ BOOST_RANGE_CONCEPT_ASSERT((
                  Convertible<
                      BOOST_DEDUCED_TYPENAME RandomAccessIteratorConcept::traversal_category,
                      random_access_traversal_tag
@@ -165,6 +208,7 @@
              BOOST_DEDUCED_TYPENAME RandomAccessIteratorConcept::difference_type n;
              Iterator i;
              Iterator j;
+ #endif
          };

     } // namespace range_detail
@@ -173,11 +217,12 @@
     template<class T>
     struct SinglePassRangeConcept
     {
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
          typedef BOOST_DEDUCED_TYPENAME range_iterator<T const>::type const_iterator;
          typedef BOOST_DEDUCED_TYPENAME range_iterator<T>::type iterator;

- BOOST_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<iterator>));
- BOOST_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<const_iterator>));
+ BOOST_RANGE_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<iterator>));
+ BOOST_RANGE_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<const_iterator>));

          BOOST_CONCEPT_USAGE(SinglePassRangeConcept)
          {
@@ -208,19 +253,23 @@
        // T to be an abstract class. The other obvious alternative of
        // T& produces a warning on some compilers.
        T* m_range;
+#endif
     };

     //! Check if a type T models the ForwardRange range concept.
     template<class T>
     struct ForwardRangeConcept : SinglePassRangeConcept<T>
     {
- BOOST_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<BOOST_DEDUCED_TYPENAME ForwardRangeConcept::iterator>));
- BOOST_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<BOOST_DEDUCED_TYPENAME ForwardRangeConcept::const_iterator>));
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ BOOST_RANGE_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<BOOST_DEDUCED_TYPENAME ForwardRangeConcept::iterator>));
+ BOOST_RANGE_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<BOOST_DEDUCED_TYPENAME ForwardRangeConcept::const_iterator>));
+#endif
     };

     template<class Range>
     struct WriteableRangeConcept
     {
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
         typedef BOOST_DEDUCED_TYPENAME range_iterator<Range>::type iterator;

         BOOST_CONCEPT_USAGE(WriteableRangeConcept)
@@ -230,6 +279,7 @@
     private:
         iterator i;
         BOOST_DEDUCED_TYPENAME range_value<Range>::type v;
+#endif
     };

     //! Check if a type T models the WriteableForwardRange range concept.
@@ -244,8 +294,10 @@
     template<class T>
     struct BidirectionalRangeConcept : ForwardRangeConcept<T>
     {
- BOOST_CONCEPT_ASSERT((BidirectionalIteratorConcept<BOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::iterator>));
- BOOST_CONCEPT_ASSERT((BidirectionalIteratorConcept<BOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::const_iterator>));
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ BOOST_RANGE_CONCEPT_ASSERT((BidirectionalIteratorConcept<BOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::iterator>));
+ BOOST_RANGE_CONCEPT_ASSERT((BidirectionalIteratorConcept<BOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::const_iterator>));
+#endif
     };

     //! Check if a type T models the WriteableBidirectionalRange range concept.
@@ -260,8 +312,10 @@
     template<class T>
     struct RandomAccessRangeConcept : BidirectionalRangeConcept<T>
     {
- BOOST_CONCEPT_ASSERT((RandomAccessIteratorConcept<BOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::iterator>));
- BOOST_CONCEPT_ASSERT((RandomAccessIteratorConcept<BOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::const_iterator>));
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
+ BOOST_RANGE_CONCEPT_ASSERT((RandomAccessIteratorConcept<BOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::iterator>));
+ BOOST_RANGE_CONCEPT_ASSERT((RandomAccessIteratorConcept<BOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::const_iterator>));
+#endif
     };

     //! Check if a type T models the WriteableRandomAccessRange range concept.

Modified: trunk/boost/range/join.hpp
==============================================================================
--- trunk/boost/range/join.hpp (original)
+++ trunk/boost/range/join.hpp 2010-04-04 06:47:21 EDT (Sun, 04 Apr 2010)
@@ -28,8 +28,8 @@
>
join(const SinglePassRange1& r1, const SinglePassRange2& r2)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));

         typedef range_detail::join_iterator<
                                 BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
@@ -50,8 +50,8 @@
>
join(SinglePassRange1& r1, SinglePassRange2& r2)
{
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
- BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));

         typedef range_detail::join_iterator<
                 BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk