feedc0de/boost_range
1
0
Fork 0
forked from boostorg/range
Code Pull Requests Activity

Merge branch 'hotfix/trac_9524_assertions_break_single_pass' into develop

Browse Source
This commit is contained in:
Neil Groves
2014-02-27 16:52:46 +00:00
parent 259e917eaf 502abb9884
commit 19f0726533
13 changed files with 189 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

190
include/boost/range/numeric.hpp
View File

@ -1,14 +1,8 @@
///////////////////////////////////////////////////////////////////////////////
/// \file algorithm.hpp
/// Contains range-based versions of the std algorithms
//
/////////////////////////////////////////////////////////////////////////////
// Copyright 2009 Neil Groves.
// Copyright 2009-2014 Neil Groves.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Copyright 2006 Thorsten Ottosen.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
@ -18,7 +12,9 @@
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Contains range-based versions of the numeric std algorithms
//
#if defined(_MSC_VER)
#pragma once
#endif
@ -30,89 +26,163 @@
#include <boost/assert.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/range/category.hpp>
#include <boost/range/concepts.hpp>
#include <boost/range/distance.hpp>
#include <boost/range/size.hpp>
#include <numeric>
namespace boost
{
template< class SinglePassRange, class Value >
inline Value accumulate( const SinglePassRange& rng, Value init )
template<class SinglePassRange, class Value>
inline Value accumulate(const SinglePassRange& rng, Value init)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::accumulate( boost::begin(rng), boost::end(rng), init );
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
return std::accumulate(boost::begin(rng), boost::end(rng), init);
}
template< class SinglePassRange, class Value, class BinaryOperation >
inline Value accumulate( const SinglePassRange& rng, Value init, BinaryOperation op )
template<class SinglePassRange, class Value, class BinaryOperation>
inline Value accumulate(const SinglePassRange& rng, Value init,
BinaryOperation op)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::accumulate( boost::begin(rng), boost::end(rng), init, op );
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange> ));
return std::accumulate(boost::begin(rng), boost::end(rng), init, op);
}
template< class SinglePassRange1, class SinglePassRange2, class Value >
inline Value inner_product( const SinglePassRange1& rng1, const SinglePassRange2& rng2, Value init )
namespace range_detail
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
BOOST_ASSERT( boost::distance(rng2) >= boost::distance(rng1) );
return std::inner_product( boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), init );
template<class SinglePassRange1, class SinglePassRange2>
inline bool inner_product_precondition(
const SinglePassRange1&,
const SinglePassRange2&,
std::input_iterator_tag,
std::input_iterator_tag)
{
return true;
}
template<class SinglePassRange1, class SinglePassRange2>
inline bool inner_product_precondition(
const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
std::forward_iterator_tag,
std::forward_iterator_tag)
{
return boost::size(rng2) >= boost::size(rng1);
}
} // namespace range_detail
template<
class SinglePassRange1,
class SinglePassRange2,
class Value
>
inline Value inner_product(
const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
Value init)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange1>));
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange2>));
BOOST_ASSERT(
range_detail::inner_product_precondition(
rng1, rng2,
typename range_category<const SinglePassRange1>::type(),
typename range_category<const SinglePassRange2>::type()));
return std::inner_product(
boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), init);
}
template< class SinglePassRange1,
class SinglePassRange2,
class Value,
class BinaryOperation1, class BinaryOperation2 >
inline Value inner_product( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
Value init,
BinaryOperation1 op1, BinaryOperation2 op2 )
template<
class SinglePassRange1,
class SinglePassRange2,
class Value,
class BinaryOperation1,
class BinaryOperation2
>
inline Value inner_product(
const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
Value init,
BinaryOperation1 op1,
BinaryOperation2 op2)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
BOOST_ASSERT( boost::distance(rng2) >= boost::distance(rng1) );
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange1>));
return std::inner_product( boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), init, op1, op2 );
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange2>));
BOOST_ASSERT(
range_detail::inner_product_precondition(
rng1, rng2,
typename range_category<const SinglePassRange1>::type(),
typename range_category<const SinglePassRange2>::type()));
return std::inner_product(
boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), init, op1, op2);
}
template< class SinglePassRange, class OutputIterator >
inline OutputIterator partial_sum ( const SinglePassRange& rng,
OutputIterator result )
template<class SinglePassRange, class OutputIterator>
inline OutputIterator partial_sum(const SinglePassRange& rng,
OutputIterator result)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::partial_sum( boost::begin(rng), boost::end(rng), result );
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
return std::partial_sum(boost::begin(rng), boost::end(rng), result);
}
template< class SinglePassRange, class OutputIterator, class BinaryOperation >
inline OutputIterator partial_sum ( const SinglePassRange& rng, OutputIterator result,
BinaryOperation op )
template<class SinglePassRange, class OutputIterator, class BinaryOperation>
inline OutputIterator partial_sum(
const SinglePassRange& rng,
OutputIterator result,
BinaryOperation op)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::partial_sum( boost::begin(rng), boost::end(rng), result, op );
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
return std::partial_sum(boost::begin(rng), boost::end(rng), result, op);
}
template< class SinglePassRange, class OutputIterator >
inline OutputIterator adjacent_difference ( const SinglePassRange& rng,
OutputIterator result )
template<class SinglePassRange, class OutputIterator>
inline OutputIterator adjacent_difference(
const SinglePassRange& rng,
OutputIterator result)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::adjacent_difference( boost::begin(rng), boost::end(rng),
result );
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
return std::adjacent_difference(boost::begin(rng), boost::end(rng),
result);
}
template< class SinglePassRange, class OutputIterator, class BinaryOperation >
inline OutputIterator adjacent_difference ( const SinglePassRange& rng,
OutputIterator result,
BinaryOperation op )
template<class SinglePassRange, class OutputIterator, class BinaryOperation>
inline OutputIterator adjacent_difference(
const SinglePassRange& rng,
OutputIterator result,
BinaryOperation op)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::adjacent_difference( boost::begin(rng), boost::end(rng),
result, op );
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
return std::adjacent_difference(boost::begin(rng), boost::end(rng),
result, op);
}
}
} // namespace boost
#endif

13
test/algorithm.cpp
View File

@ -107,12 +107,15 @@ template<typename Rng>
void test_random_algorithms(Rng & rng, std::random_access_iterator_tag)
{
typedef BOOST_DEDUCED_TYPENAME boost::range_iterator<Rng>::type iterator;
typedef BOOST_DEDUCED_TYPENAME boost::range_value<Rng>::type value_type;
typedef BOOST_DEDUCED_TYPENAME boost::range_size<Rng>::type size_type BOOST_RANGE_UNUSED;
typedef BOOST_DEDUCED_TYPENAME boost::iterator_category<iterator>::type iterator_category;
typedef BOOST_DEDUCED_TYPENAME boost::range_value<Rng>::type value_type;
typedef BOOST_DEDUCED_TYPENAME boost::range_size<Rng>::type
size_type BOOST_RANGE_UNUSED;
typedef BOOST_DEDUCED_TYPENAME boost::iterator_category<iterator>::type
iterator_category BOOST_RANGE_UNUSED;
// just make sure these compile (for now)
if(0)
{

7
test/algorithm_test/inplace_merge.cpp
View File

@ -28,7 +28,9 @@ namespace boost
void test(Container1& cont1, Container2& cont2)
{
typedef BOOST_DEDUCED_TYPENAME Container1::value_type value_t;
typedef BOOST_DEDUCED_TYPENAME std::vector<value_t>::iterator iterator_t;
typedef BOOST_DEDUCED_TYPENAME std::vector<value_t>::iterator
iterator_t BOOST_RANGE_UNUSED;
std::vector<value_t> reference_target(cont1.begin(), cont1.end());
reference_target.insert(reference_target.end(),
@ -74,7 +76,8 @@ namespace boost
void test_pred(Container1 cont1, Container2 cont2, BinaryPredicate pred)
{
typedef BOOST_DEDUCED_TYPENAME Container1::value_type value_t;
typedef BOOST_DEDUCED_TYPENAME std::vector<value_t>::iterator iterator_t;
typedef BOOST_DEDUCED_TYPENAME std::vector<value_t>::iterator
iterator_t BOOST_RANGE_UNUSED;
sort_container(cont1, pred);
sort_container(cont2, pred);

7
test/algorithm_test/max_element.cpp
View File

@ -106,8 +106,11 @@ namespace boost_range_test_algorithm_max_element
{
using namespace boost::assign;
typedef BOOST_DEDUCED_TYPENAME Container::value_type value_t;
typedef BOOST_DEDUCED_TYPENAME boost::remove_const<Container>::type container_t;
typedef BOOST_DEDUCED_TYPENAME Container::value_type
value_t BOOST_RANGE_UNUSED;
typedef BOOST_DEDUCED_TYPENAME boost::remove_const<Container>::type
container_t;
boost::range_test::range_return_test_driver test_driver;

7
test/algorithm_test/min_element.cpp
View File

@ -104,8 +104,11 @@ namespace boost_range_test_algorithm_min_element
{
using namespace boost::assign;
typedef BOOST_DEDUCED_TYPENAME Container::value_type value_t;
typedef BOOST_DEDUCED_TYPENAME boost::remove_const<Container>::type container_t;
typedef BOOST_DEDUCED_TYPENAME Container::value_type
value_t BOOST_RANGE_UNUSED;
typedef BOOST_DEDUCED_TYPENAME boost::remove_const<Container>::type
container_t;
boost::range_test::range_return_test_driver test_driver;

18
test/algorithm_test/mismatch.cpp
View File

@ -160,15 +160,17 @@ namespace boost
MutableContainer2 cont2;
const Container2& cref_cont2 = cont2;
typedef BOOST_DEDUCED_TYPENAME Container1::iterator iterator1_t;
typedef BOOST_DEDUCED_TYPENAME Container1::const_iterator const_iterator1_t;
typedef BOOST_DEDUCED_TYPENAME Container2::iterator iterator2_t;
typedef BOOST_DEDUCED_TYPENAME Container2::const_iterator const_iterator2_t;
typedef BOOST_DEDUCED_TYPENAME Container1::iterator
iterator1_t BOOST_RANGE_UNUSED;
typedef std::pair<iterator1_t, iterator2_t> pair_mmit_t;
typedef std::pair<const_iterator1_t, iterator2_t> pair_cmit_t;
typedef std::pair<iterator1_t, const_iterator2_t> pair_mcit_t;
typedef std::pair<const_iterator1_t, const_iterator2_t> pair_ccit_t;
typedef BOOST_DEDUCED_TYPENAME Container1::const_iterator
const_iterator1_t BOOST_RANGE_UNUSED;
typedef BOOST_DEDUCED_TYPENAME Container2::iterator
iterator2_t BOOST_RANGE_UNUSED;
typedef BOOST_DEDUCED_TYPENAME Container2::const_iterator
const_iterator2_t BOOST_RANGE_UNUSED;
eval_mismatch(cont1, cont2, cont1.end(), cont2.end());
eval_mismatch(cont1, cont2, std::equal_to<int>(), cont1.end(), cont2.end());

3
test/algorithm_test/random_shuffle.cpp
View File

@ -90,7 +90,8 @@ namespace boost
template<class Container>
void test_random_shuffle_nogen_impl(Container& cont)
{
typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iterator_t;
typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
iterator_t BOOST_RANGE_UNUSED;
const int MAX_RETRIES = 10000;

3
test/algorithm_test/remove_copy.cpp
View File

@ -36,7 +36,8 @@ namespace
typedef typename boost::range_value<Container>::type value_type;
std::vector<value_type> reference;
typedef BOOST_DEDUCED_TYPENAME std::vector<value_type>::iterator iterator_t;
typedef BOOST_DEDUCED_TYPENAME std::vector<value_type>::iterator
iterator_t BOOST_RANGE_UNUSED;
test_append(
std::remove_copy(c.begin(), c.end(),

3
test/algorithm_test/replace_copy.cpp
View File

@ -38,7 +38,8 @@ namespace
typedef typename boost::range_value<Container>::type value_type;
std::vector<value_type> reference;
typedef BOOST_DEDUCED_TYPENAME std::vector<value_type>::iterator iterator_t;
typedef BOOST_DEDUCED_TYPENAME std::vector<value_type>::iterator
iterator_t BOOST_RANGE_UNUSED;
test_append(
std::replace_copy(c.begin(), c.end(),

7
test/algorithm_test/rotate_copy.cpp
View File

@ -31,11 +31,14 @@ namespace
template<class Container, class Iterator>
void test_rotate_copy_impl(Container& cont, Iterator where_it)
{
typedef BOOST_DEDUCED_TYPENAME boost::range_value<Container>::type value_type;
typedef BOOST_DEDUCED_TYPENAME boost::range_value<Container>::type
value_type;
std::vector<value_type> reference;
std::vector<value_type> test;
typedef BOOST_DEDUCED_TYPENAME boost::range_iterator<Container>::type iterator_t;
typedef BOOST_DEDUCED_TYPENAME boost::range_iterator<Container>::type
iterator_t BOOST_RANGE_UNUSED;
test_append(
std::rotate_copy(cont.begin(), where_it, cont.end(),

4
test/algorithm_test/search_n.cpp
View File

@ -60,7 +60,9 @@ namespace
Integer count, const Value& value,
BinaryPredicate pred)
{
typedef typename std::iterator_traits<ForwardIterator>::iterator_category cat_t;
typedef typename std::iterator_traits<
ForwardIterator
>::iterator_category cat_t BOOST_RANGE_UNUSED;
if (count <= 0)
return first;

2
test/compat3.cpp
View File

@ -10,6 +10,7 @@
#include <boost/static_assert.hpp>
#include <boost/type_traits.hpp>
#include <boost/concept_check.hpp>
#include <boost/config.hpp>
enum Container {};
@ -51,6 +52,7 @@ void compat1()
{
std::vector<int> v;
iterator_of< std::vector<int> >::type i = v.begin();
boost::ignore_unused_variable_warning(i);
}
#include <boost/test/included/unit_test.hpp>

14
test/iterator_pair.cpp
View File

@ -63,18 +63,24 @@ void check_iterator_pair()
BOOST_CHECK( boost::begin( pair ) == pair.first );
BOOST_CHECK( boost::end( pair ) == pair.second );
BOOST_CHECK( boost::empty( pair ) == (pair.first == pair.second) );
BOOST_CHECK( boost::size( pair ) == std::distance( pair.first, pair.second ) );
BOOST_CHECK( boost::size( pair ) ==
static_cast<std::size_t>(
std::distance(pair.first, pair.second)) );
BOOST_CHECK( boost::begin( const_pair ) == const_pair.first );
BOOST_CHECK( boost::end( const_pair ) == const_pair.second );
BOOST_CHECK( boost::empty( const_pair ) == (const_pair.first == const_pair.second) );
BOOST_CHECK( boost::size( const_pair ) == std::distance( const_pair.first, const_pair.second ) );
BOOST_CHECK( boost::size( const_pair ) ==
static_cast<std::size_t>(
std::distance(const_pair.first, const_pair.second)) );
BOOST_CHECK( boost::begin( constness_pair ) == constness_pair.first );
BOOST_CHECK( boost::end( constness_pair ) == constness_pair.second );
BOOST_CHECK( boost::empty( constness_pair ) == (constness_pair.first == const_pair.second) );
BOOST_CHECK( boost::size( constness_pair ) == std::distance( constness_pair.first, constness_pair.second ) );
BOOST_CHECK( boost::size( constness_pair ) ==
static_cast<std::size_t>(
std::distance(constness_pair.first,
constness_pair.second)) );
}