Subject: [Boost-commit] svn:boost r61042 - in trunk: boost/range boost/range/algorithm boost/range/algorithm_ext libs/range/doc/reference libs/range/doc/reference/algorithm_ext libs/range/test libs/range/test/algorithm_ext_test
From: neil_at_[hidden]
Date: 2010-04-04 10:14:15
Author: neilgroves
Date: 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
New Revision: 61042
URL: http://svn.boost.org/trac/boost/changeset/61042
Log:
Boost.Range added unit tests for extended algorithms.
Put the extended algorithms into boost::range in a similar manner to the standard algorithms.
Added iota as an extended algorithm.
Fixed defects in the extended algorithms brought to light by the new unit tests.
Added:
trunk/boost/range/algorithm_ext/iota.hpp (contents, props changed)
trunk/libs/range/doc/reference/algorithm_ext/iota.qbk (contents, props changed)
trunk/libs/range/test/algorithm_ext_test/
trunk/libs/range/test/algorithm_ext_test/copy_n.cpp (contents, props changed)
trunk/libs/range/test/algorithm_ext_test/erase.cpp (contents, props changed)
trunk/libs/range/test/algorithm_ext_test/for_each_ext.cpp (contents, props changed)
trunk/libs/range/test/algorithm_ext_test/insert.cpp (contents, props changed)
trunk/libs/range/test/algorithm_ext_test/iota.cpp (contents, props changed)
trunk/libs/range/test/algorithm_ext_test/is_sorted.cpp (contents, props changed)
trunk/libs/range/test/algorithm_ext_test/overwrite.cpp (contents, props changed)
trunk/libs/range/test/algorithm_ext_test/push_back.cpp (contents, props changed)
trunk/libs/range/test/algorithm_ext_test/push_front.cpp (contents, props changed)
Text files modified:
trunk/boost/range/algorithm/for_each.hpp | 4 +-
trunk/boost/range/algorithm_ext.hpp | 1
trunk/boost/range/algorithm_ext/copy_n.hpp | 40 ++++++++++++---------
trunk/boost/range/algorithm_ext/erase.hpp | 57 ++++++++++++++++++-----------
trunk/boost/range/algorithm_ext/for_each.hpp | 75 +++++++++++++++++++++++++--------------
trunk/boost/range/algorithm_ext/insert.hpp | 27 +++++++++----
trunk/boost/range/algorithm_ext/is_sorted.hpp | 48 ++++++++++++++-----------
trunk/boost/range/algorithm_ext/overwrite.hpp | 47 +++++++++++++++---------
trunk/boost/range/algorithm_ext/push_back.hpp | 22 ++++++++---
trunk/boost/range/algorithm_ext/push_front.hpp | 23 ++++++++---
trunk/libs/range/doc/reference/algorithms.qbk | 1
trunk/libs/range/test/Jamfile.v2 | 9 ++++
12 files changed, 224 insertions(+), 130 deletions(-)
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 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -35,10 +35,10 @@
/// \overload
template< class SinglePassRange, class UnaryFunction >
-inline UnaryFunction for_each(SinglePassRange const & rng, UnaryFunction fun)
+inline UnaryFunction for_each(const SinglePassRange& rng, UnaryFunction fun)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
- return std::for_each(boost::begin(rng),boost::end(rng),fun);
+ return std::for_each(boost::begin(rng), boost::end(rng), fun);
}
} // namespace range
Modified: trunk/boost/range/algorithm_ext.hpp
==============================================================================
--- trunk/boost/range/algorithm_ext.hpp (original)
+++ trunk/boost/range/algorithm_ext.hpp 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -18,6 +18,7 @@
#include <boost/range/algorithm_ext/copy_n.hpp>
#include <boost/range/algorithm_ext/for_each.hpp>
#include <boost/range/algorithm_ext/is_sorted.hpp>
+#include <boost/range/algorithm_ext/iota.hpp>
#include <boost/range/algorithm_ext/overwrite.hpp>
#include <boost/range/algorithm_ext/push_back.hpp>
#include <boost/range/algorithm_ext/push_front.hpp>
Modified: trunk/boost/range/algorithm_ext/copy_n.hpp
==============================================================================
--- trunk/boost/range/algorithm_ext/copy_n.hpp (original)
+++ trunk/boost/range/algorithm_ext/copy_n.hpp 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -21,27 +21,33 @@
namespace boost
{
- /// \brief template function copy
- ///
- /// range-based version of the copy std algorithm
- ///
- /// \pre SinglePassRange is a model of the SinglePassRangeConcept
- /// \pre OutputIterator is a model of the OutputIteratorConcept
- /// \pre 0 <= n < distance(rng)
- template< class SinglePassRange, class Size, class OutputIterator >
- inline OutputIterator copy_n(const SinglePassRange& rng, Size n, OutputIterator out)
+ namespace range
{
- boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
- BOOST_ASSERT( n < static_cast<Size>(boost::distance(rng)) );
- BOOST_ASSERT( n >= static_cast<Size>(0) );
- BOOST_DEDUCED_TYPENAME range_const_iterator<SinglePassRange>::type source = boost::begin(rng);
+/// \brief template function copy
+///
+/// range-based version of the copy std algorithm
+///
+/// \pre SinglePassRange is a model of the SinglePassRangeConcept
+/// \pre OutputIterator is a model of the OutputIteratorConcept
+/// \pre 0 <= n < distance(rng)
+template< class SinglePassRange, class Size, class OutputIterator >
+inline OutputIterator copy_n(const SinglePassRange& rng, Size n, OutputIterator out)
+{
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+ BOOST_ASSERT( n < static_cast<Size>(boost::distance(rng)) );
+ BOOST_ASSERT( n >= static_cast<Size>(0) );
+
+ BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type source = boost::begin(rng);
- for (Size i = 0; i < n; ++i, ++out, ++source)
- *out = *source;
+ for (Size i = 0; i < n; ++i, ++out, ++source)
+ *out = *source;
- return out;
- }
+ return out;
}
+ } // namespace range
+ using range::copy_n;
+} // namespace boost
+
#endif // include guard
Modified: trunk/boost/range/algorithm_ext/erase.hpp
==============================================================================
--- trunk/boost/range/algorithm_ext/erase.hpp (original)
+++ trunk/boost/range/algorithm_ext/erase.hpp 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -11,35 +11,48 @@
#define BOOST_RANGE_ALGORITHM_EXT_ERASE_HPP_INCLUDED
#include <boost/range/config.hpp>
+#include <boost/range/concepts.hpp>
#include <boost/range/difference_type.hpp>
+#include <boost/range/iterator_range_core.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/assert.hpp>
namespace boost
{
- template< class Container >
- inline void erase( Container& on,
- iterator_range<BOOST_DEDUCED_TYPENAME Container::iterator> to_erase )
- {
- on.erase( boost::begin(to_erase), boost::end(to_erase) );
- }
-
- template< class Container, class T >
- inline void remove_erase( Container& on, const T& val )
- {
- on.erase(
- std::remove(boost::begin(on), boost::end(on), val),
- boost::end(on));
- }
-
- template< class Container, class Pred >
- inline void remove_erase_if( Container& on, Pred pred )
- {
- on.erase(
- std::remove_if(boost::begin(on), boost::end(on), pred),
- boost::end(on));
- }
+ namespace range
+ {
+
+template< class Container >
+inline void erase( Container& on,
+ iterator_range<BOOST_DEDUCED_TYPENAME Container::iterator> to_erase )
+{
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<Container> ));
+ on.erase( boost::begin(to_erase), boost::end(to_erase) );
+}
+
+template< class Container, class T >
+inline void remove_erase( Container& on, const T& val )
+{
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<Container> ));
+ on.erase(
+ std::remove(boost::begin(on), boost::end(on), val),
+ boost::end(on));
}
+template< class Container, class Pred >
+inline void remove_erase_if( Container& on, Pred pred )
+{
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<Container> ));
+ on.erase(
+ std::remove_if(boost::begin(on), boost::end(on), pred),
+ boost::end(on));
+}
+
+ } // namespace range
+ using range::erase;
+ using range::remove_erase;
+ using range::remove_erase_if;
+} // namespace boost
+
#endif // include guard
Modified: trunk/boost/range/algorithm_ext/for_each.hpp
==============================================================================
--- trunk/boost/range/algorithm_ext/for_each.hpp (original)
+++ trunk/boost/range/algorithm_ext/for_each.hpp 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -11,6 +11,7 @@
#define BOOST_RANGE_ALGORITHM_EXT_FOR_EACH_HPP_INCLUDED
#include <boost/range/config.hpp>
+#include <boost/range/concepts.hpp>
#include <boost/range/difference_type.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
@@ -33,33 +34,53 @@
}
}
- template<class SinglePassRange1, class SinglePassRange2, class Fn2>
- inline Fn2 for_each(const SinglePassRange1& rng1, const SinglePassRange2& rng2, Fn2 fn)
+ namespace range
{
- return range_detail::for_each_impl(boost::begin(rng1), boost::end(rng1),
- boost::begin(rng2), boost::end(rng2), fn);
- }
-
- template<class SinglePassRange1, class SinglePassRange2, class Fn2>
- inline Fn2 for_each(const SinglePassRange1& rng1, SinglePassRange2& rng2, Fn2 fn)
- {
- return range_detail::for_each_impl(boost::begin(rng1), boost::end(rng1),
- boost::begin(rng2), boost::end(rng2), fn);
- }
-
- template<class SinglePassRange1, class SinglePassRange2, class Fn2>
- inline Fn2 for_each(SinglePassRange1& rng1, const SinglePassRange2& rng2, Fn2 fn)
- {
- return range_detail::for_each_impl(boost::begin(rng1), boost::end(rng1),
- boost::begin(rng2), boost::end(rng2), fn);
- }
-
- template<class SinglePassRange1, class SinglePassRange2, class Fn2>
- inline Fn2 for_each(SinglePassRange1& rng1, SinglePassRange2& rng2, Fn2 fn)
- {
- return range_detail::for_each_impl(boost::begin(rng1), boost::end(rng1),
- boost::begin(rng2), boost::end(rng2), fn);
- }
-}
+ template<class SinglePassRange1, class SinglePassRange2, class Fn2>
+ inline Fn2 for_each(const SinglePassRange1& rng1, const SinglePassRange2& rng2, Fn2 fn)
+ {
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+
+ return ::boost::range_detail::for_each_impl(
+ ::boost::begin(rng1), ::boost::end(rng1),
+ ::boost::begin(rng2), ::boost::end(rng2), fn);
+ }
+
+ template<class SinglePassRange1, class SinglePassRange2, class Fn2>
+ inline Fn2 for_each(const SinglePassRange1& rng1, SinglePassRange2& rng2, Fn2 fn)
+ {
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+
+ return ::boost::range_detail::for_each_impl(
+ ::boost::begin(rng1), ::boost::end(rng1),
+ ::boost::begin(rng2), ::boost::end(rng2), fn);
+ }
+
+ template<class SinglePassRange1, class SinglePassRange2, class Fn2>
+ inline Fn2 for_each(SinglePassRange1& rng1, const SinglePassRange2& rng2, Fn2 fn)
+ {
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+
+ return ::boost::range_detail::for_each_impl(
+ ::boost::begin(rng1), ::boost::end(rng1),
+ ::boost::begin(rng2), ::boost::end(rng2), fn);
+ }
+
+ template<class SinglePassRange1, class SinglePassRange2, class Fn2>
+ inline Fn2 for_each(SinglePassRange1& rng1, SinglePassRange2& rng2, Fn2 fn)
+ {
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+
+ return ::boost::range_detail::for_each_impl(
+ ::boost::begin(rng1), ::boost::end(rng1),
+ ::boost::begin(rng2), ::boost::end(rng2), fn);
+ }
+ } // namespace range
+ using range::for_each;
+} // namespace boost
#endif // include guard
Modified: trunk/boost/range/algorithm_ext/insert.hpp
==============================================================================
--- trunk/boost/range/algorithm_ext/insert.hpp (original)
+++ trunk/boost/range/algorithm_ext/insert.hpp 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -11,6 +11,7 @@
#define BOOST_RANGE_ALGORITHM_EXT_INSERT_HPP_INCLUDED
#include <boost/range/config.hpp>
+#include <boost/range/concepts.hpp>
#include <boost/range/difference_type.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
@@ -18,15 +19,23 @@
namespace boost
{
- template< class Container, class Range >
- inline void insert( Container& on,
- BOOST_DEDUCED_TYPENAME Container::iterator before,
- const Range& from )
- {
- BOOST_ASSERT( (void*)&on != (void*)&from &&
- "cannot copy from a container to itself" );
- on.insert( before, boost::begin(from), boost::end(from) );
- }
+ namespace range
+ {
+
+template< class Container, class Range >
+inline void insert( Container& on,
+ BOOST_DEDUCED_TYPENAME Container::iterator before,
+ const Range& from )
+{
+ BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<Container> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<Range> ));
+ BOOST_ASSERT( (void*)&on != (void*)&from &&
+ "cannot copy from a container to itself" );
+ on.insert( before, boost::begin(from), boost::end(from) );
}
+ } // namespace range
+ using range::insert;
+} // namespace boost
+
#endif // include guard
Added: trunk/boost/range/algorithm_ext/iota.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/range/algorithm_ext/iota.hpp 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -0,0 +1,39 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2009. Use, modification and
+// distribution is subject to 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)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_EXT_IOTA_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_EXT_IOTA_HPP_INCLUDED
+
+#include <boost/range/config.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+namespace boost
+{
+ namespace range
+ {
+
+template< class ForwardRange, class Value >
+inline void iota( ForwardRange& rng, Value x )
+{
+ BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+ typedef BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type iterator_t;
+
+ iterator_t last_target = ::boost::end(rng);
+ for (iterator_t target = ::boost::begin(rng); target != last_target; ++target, ++x)
+ *target = x;
+}
+
+ } // namespace range
+ using range::iota;
+} // namespace boost
+
+#endif // include guard
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 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -20,7 +20,7 @@
{
namespace range_detail
{
- template<typename ForwardIterator>
+ template<class ForwardIterator>
inline bool is_sorted(ForwardIterator first, ForwardIterator last)
{
for (ForwardIterator next = first; first != last && ++next != last; ++first)
@@ -29,7 +29,7 @@
return true;
}
- template<typename ForwardIterator, typename BinaryPredicate>
+ template<class ForwardIterator, class BinaryPredicate>
inline bool is_sorted(ForwardIterator first, ForwardIterator last, BinaryPredicate pred)
{
for (ForwardIterator next = first; first != last && ++next != last; ++first)
@@ -39,27 +39,33 @@
}
}
- /// \brief template function count
- ///
- /// range-based version of the count std algorithm
- ///
- /// \pre SinglePassRange is a model of the SinglePassRangeConcept
- template<typename SinglePassRange>
- inline bool is_sorted(const SinglePassRange& rng)
+ namespace range
{
- 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));
- }
- /// \overload
- template<typename SinglePassRange, typename BinaryPredicate>
- inline bool is_sorted(const SinglePassRange& rng, BinaryPredicate pred)
- {
- 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);
- }
+/// \brief template function count
+///
+/// range-based version of the count std algorithm
+///
+/// \pre SinglePassRange is a model of the SinglePassRangeConcept
+template<class SinglePassRange>
+inline bool is_sorted(const SinglePassRange& rng)
+{
+ BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((LessThanComparableConcept<BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type>));
+ return range_detail::is_sorted(boost::begin(rng), boost::end(rng));
}
+/// \overload
+template<class SinglePassRange, class BinaryPredicate>
+inline bool is_sorted(const SinglePassRange& rng, BinaryPredicate pred)
+{
+ BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type, BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type>));
+ return range_detail::is_sorted(boost::begin(rng), boost::end(rng), pred);
+}
+
+ } // namespace range
+ using range::is_sorted;
+} // namespace boost
+
#endif // include guard
Modified: trunk/boost/range/algorithm_ext/overwrite.hpp
==============================================================================
--- trunk/boost/range/algorithm_ext/overwrite.hpp (original)
+++ trunk/boost/range/algorithm_ext/overwrite.hpp 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -11,36 +11,47 @@
#define BOOST_RANGE_ALGORITHM_EXT_OVERWRITE_HPP_INCLUDED
#include <boost/range/config.hpp>
+#include <boost/range/concepts.hpp>
#include <boost/range/difference_type.hpp>
+#include <boost/range/iterator.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/assert.hpp>
namespace boost
{
- template< class SinglePassRange1, class SinglePassRange2 >
- inline void overwrite( const SinglePassRange1& from, SinglePassRange2& to )
- {
- BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
- i = boost::begin(from), e = boost::end(from);
-
- BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type
- out = boost::begin(to);
-
+ namespace range
+ {
+
+template< class SinglePassRange1, class SinglePassRange2 >
+inline void overwrite( const SinglePassRange1& from, SinglePassRange2& to )
+{
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+
+ BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type
+ i = boost::begin(from), e = boost::end(from);
+
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type
+ out = boost::begin(to);
+
#ifndef NDEBUG
- BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type
- last_out = boost::end(to);
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type
+ last_out = boost::end(to);
#endif
- for( ; i != e; ++out, ++i )
- {
+ for( ; i != e; ++out, ++i )
+ {
#ifndef NDEBUG
- BOOST_ASSERT( out != last_out
- && "out of bounds in boost::overwrite()" );
+ BOOST_ASSERT( out != last_out
+ && "out of bounds in boost::overwrite()" );
#endif
- *out = *i;
- }
- }
+ *out = *i;
+ }
}
+ } // namespace range
+ using range::overwrite;
+} // namespace boost
+
#endif // include guard
Modified: trunk/boost/range/algorithm_ext/push_back.hpp
==============================================================================
--- trunk/boost/range/algorithm_ext/push_back.hpp (original)
+++ trunk/boost/range/algorithm_ext/push_back.hpp 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -11,6 +11,7 @@
#define BOOST_RANGE_ALGORITHM_EXT_PUSH_BACK_HPP_INCLUDED
#include <boost/range/config.hpp>
+#include <boost/range/concepts.hpp>
#include <boost/range/difference_type.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
@@ -18,14 +19,21 @@
namespace boost
{
- template< class Container, class Range >
- inline void push_back( Container& on, const Range& from )
- {
- BOOST_ASSERT( (void*)&on != (void*)&from &&
- "cannot copy from a container to itself" );
- on.insert( on.end(), boost::begin(from), boost::end(from) );
- }
+ namespace range
+ {
+template< class Container, class Range >
+inline void push_back( Container& on, const Range& from )
+{
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<Container> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const Range> ));
+ BOOST_ASSERT( (void*)&on != (void*)&from &&
+ "cannot copy from a container to itself" );
+ on.insert( on.end(), boost::begin(from), boost::end(from) );
}
+ } // namespace range
+ using range::push_back;
+} // namespace boost
+
#endif // include guard
Modified: trunk/boost/range/algorithm_ext/push_front.hpp
==============================================================================
--- trunk/boost/range/algorithm_ext/push_front.hpp (original)
+++ trunk/boost/range/algorithm_ext/push_front.hpp 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -11,6 +11,7 @@
#define BOOST_RANGE_ALGORITHM_EXT_PUSH_FRONT_HPP_INCLUDED
#include <boost/range/config.hpp>
+#include <boost/range/concepts.hpp>
#include <boost/range/difference_type.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
@@ -18,13 +19,21 @@
namespace boost
{
- template< class Container, class Range >
- inline void push_front( Container& on, const Range& from )
- {
- BOOST_ASSERT( (void*)&on != (void*)&from &&
- "cannot copy from a container to itself" );
- on.insert( on.begin(), boost::begin(from), boost::end(from) );
- }
+ namespace range
+ {
+
+template< class Container, class Range >
+inline void push_front( Container& on, const Range& from )
+{
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<Container> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const Range> ));
+ BOOST_ASSERT( (void*)&on != (void*)&from &&
+ "cannot copy from a container to itself" );
+ on.insert( on.begin(), boost::begin(from), boost::end(from) );
}
+ } // namespace range
+ using range::push_front;
+} // namespace boost
+
#endif // include guard
Added: trunk/libs/range/doc/reference/algorithm_ext/iota.qbk
==============================================================================
--- (empty file)
+++ trunk/libs/range/doc/reference/algorithm_ext/iota.qbk 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -0,0 +1,28 @@
+[section:for_each for_each]
+
+[heading Prototype]
+
+``
+template<class SinglePassRange, class Value>
+iota(SinglePassRange& rng, Value x);
+``
+
+[heading Description]
+
+`iota` traverses forward through `rng`, each element `y` in `rng` is assigned a value equivalent
+to `x + boost::distance(boost::begin(rng), it)`
+
+[heading Definition]
+
+Defined in the header file `boost/range/algorithm_ext/iota.hpp`
+
+[heading Requirements]
+
+# `SinglePassRange` is a model of the __single_pass_range__ Concept.
+# `Value` is a model of the `Incrementable` Concept.
+
+[heading Complexity]
+
+Linear. Exactly `distance(rng)` assignments into `rng`.
+
+[endsect]
Modified: trunk/libs/range/doc/reference/algorithms.qbk
==============================================================================
--- trunk/libs/range/doc/reference/algorithms.qbk (original)
+++ trunk/libs/range/doc/reference/algorithms.qbk 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -144,6 +144,7 @@
[include algorithm_ext/erase.qbk]
[include algorithm_ext/for_each.qbk]
[include algorithm_ext/insert.qbk]
+[include algorithm_ext/iota.qbk]
[include algorithm_ext/overwrite.qbk]
[include algorithm_ext/push_back.qbk]
[include algorithm_ext/push_front.qbk]
Modified: trunk/libs/range/test/Jamfile.v2
==============================================================================
--- trunk/libs/range/test/Jamfile.v2 (original)
+++ trunk/libs/range/test/Jamfile.v2 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -106,6 +106,15 @@
[ range-test algorithm_test/transform ]
[ range-test algorithm_test/unique ]
[ range-test algorithm_test/upper_bound ]
+ [ range-test algorithm_ext_test/copy_n ]
+ [ range-test algorithm_ext_test/erase ]
+ [ range-test algorithm_ext_test/for_each_ext ]
+ [ range-test algorithm_ext_test/insert ]
+ [ range-test algorithm_ext_test/iota ]
+ [ range-test algorithm_ext_test/is_sorted ]
+ [ range-test algorithm_ext_test/overwrite ]
+ [ range-test algorithm_ext_test/push_back ]
+ [ range-test algorithm_ext_test/push_front ]
[ range-test adl_conformance ]
[ range-test adl_conformance_no_using ]
[ range-test algorithm ]
Added: trunk/libs/range/test/algorithm_ext_test/copy_n.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/range/test/algorithm_ext_test/copy_n.cpp 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -0,0 +1,60 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2010. Use, modification and
+// distribution is subject to 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)
+//
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#include <boost/range/algorithm_ext/copy_n.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <boost/range/iterator.hpp>
+#include <algorithm>
+#include <list>
+#include <vector>
+
+namespace
+{
+ template< class Container >
+ void test_copy_n_impl()
+ {
+ std::vector<std::size_t> source;
+ for (std::size_t i = 0; i < 10; ++i)
+ source.push_back(i);
+
+ for (std::size_t k = 0; k < 10; ++k)
+ {
+ std::vector<std::size_t> reference;
+ for (std::size_t j = 0; j < k; ++j)
+ reference.push_back(j);
+
+ Container test;
+ boost::copy_n(source, k, std::back_inserter(test));
+
+ BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+ test.begin(), test.end() );
+ }
+ }
+
+ void test_copy_n()
+ {
+ test_copy_n_impl< std::vector<std::size_t> >();
+ test_copy_n_impl< std::list<std::size_t> >();
+ }
+}
+
+boost::unit_test::test_suite*
+init_unit_test_suite(int argc, char* argv[])
+{
+ boost::unit_test::test_suite* test
+ = BOOST_TEST_SUITE( "RangeTestSuite.algorithm_ext.copy_n" );
+
+ test->add( BOOST_TEST_CASE( &test_copy_n ) );
+
+ return test;
+}
Added: trunk/libs/range/test/algorithm_ext_test/erase.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/range/test/algorithm_ext_test/erase.cpp 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -0,0 +1,128 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2010. Use, modification and
+// distribution is subject to 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)
+//
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#include <boost/range/algorithm_ext/erase.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <boost/range/iterator.hpp>
+#include <algorithm>
+#include <list>
+#include <vector>
+
+namespace
+{
+ template< class Container >
+ void test_erase_impl()
+ {
+ Container source;
+ for (int i = 0; i < 10; ++i)
+ source.push_back(i);
+
+ Container reference(source);
+ Container test(source);
+
+ typedef BOOST_DEDUCED_TYPENAME Container::iterator iterator_t;
+
+ iterator_t first_ref = reference.begin();
+ iterator_t last_ref = reference.end();
+
+ boost::iterator_range< iterator_t > test_range(test.begin(), test.end());
+
+ reference.erase(first_ref, last_ref);
+ boost::erase(test, test_range);
+
+ BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+ test.begin(), test.end() );
+ }
+
+ void test_erase()
+ {
+ test_erase_impl<std::vector<int> >();
+ test_erase_impl<std::list<int> >();
+ }
+
+ template< class Container >
+ void test_remove_erase_impl()
+ {
+ Container source;
+ for (int i = 0; i < 10; ++i)
+ source.push_back(i);
+
+ Container reference(source);
+ Container test(source);
+
+ boost::remove_erase(test, 5);
+
+ reference.erase( std::find(reference.begin(), reference.end(), 5) );
+
+ BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+ test.begin(), test.end() );
+ }
+
+ void test_remove_erase()
+ {
+ test_remove_erase_impl<std::vector<int> >();
+ test_remove_erase_impl<std::list<int> >();
+ }
+
+ struct is_even
+ {
+ typedef bool result_type;
+ typedef int argument_type;
+ bool operator()(int x) const { return x % 2 == 0; }
+ };
+
+ template< class Container >
+ void test_remove_erase_if_impl()
+ {
+ Container source;
+ for (int i = 0; i < 10; ++i)
+ source.push_back(i);
+
+ Container reference;
+ typedef BOOST_DEDUCED_TYPENAME Container::const_iterator iterator_t;
+ iterator_t last_source = source.end();
+ is_even pred;
+ for (iterator_t it_source = source.begin(); it_source != last_source; ++it_source)
+ {
+ if (!pred(*it_source))
+ reference.push_back(*it_source);
+ }
+
+ Container test(source);
+ boost::remove_erase_if(test, is_even());
+
+ BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+ test.begin(), test.end() );
+
+ }
+
+ void test_remove_erase_if()
+ {
+ test_remove_erase_if_impl<std::vector<int> >();
+ test_remove_erase_if_impl<std::list<int> >();
+ }
+
+}
+
+boost::unit_test::test_suite*
+init_unit_test_suite(int argc, char* argv[])
+{
+ boost::unit_test::test_suite* test
+ = BOOST_TEST_SUITE( "RangeTestSuite.algorithm_ext.erase" );
+
+ test->add( BOOST_TEST_CASE( &test_erase ) );
+ test->add( BOOST_TEST_CASE( &test_remove_erase ) );
+ test->add( BOOST_TEST_CASE( &test_remove_erase_if ) );
+
+ return test;
+}
Added: trunk/libs/range/test/algorithm_ext_test/for_each_ext.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/range/test/algorithm_ext_test/for_each_ext.cpp 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -0,0 +1,98 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2010. Use, modification and
+// distribution is subject to 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)
+//
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#include <boost/range/algorithm_ext/for_each.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <boost/range/iterator.hpp>
+#include <algorithm>
+#include <list>
+#include <vector>
+
+namespace
+{
+ struct MockBinaryFn
+ {
+ typedef void result_type;
+ typedef int first_argument_type;
+ typedef int second_argument_type;
+
+ void operator()(int x, int y)
+ {
+ xs.push_back(x);
+ ys.push_back(y);
+ }
+
+ std::vector<int> xs;
+ std::vector<int> ys;
+ };
+
+ template< class Range1, class Range2 >
+ void test_for_each_impl( Range1& rng1, Range2& rng2 )
+ {
+ MockBinaryFn fn = boost::range::for_each(rng1, rng2, MockBinaryFn());
+
+ BOOST_CHECK_EQUAL_COLLECTIONS( ::boost::begin(rng1), ::boost::end(rng1),
+ fn.xs.begin(), fn.xs.end() );
+
+ BOOST_CHECK_EQUAL_COLLECTIONS( ::boost::begin(rng2), ::boost::end(rng2),
+ fn.ys.begin(), fn.ys.end() );
+ }
+
+ template< class Collection1, class Collection2 >
+ void test_for_each_impl(const int max_count)
+ {
+ Collection1 c1;
+ for (int i = 0; i < max_count; ++i)
+ c1.push_back(i);
+
+ Collection2 c2;
+ for (int i = 0; i < max_count; ++i)
+ c2.push_back(i);
+
+ test_for_each_impl(c1, c2);
+
+ const Collection1& const_c1 = c1;
+ const Collection2& const_c2 = c2;
+
+ test_for_each_impl(c1, const_c2);
+ test_for_each_impl(const_c1, c2);
+ test_for_each_impl(const_c1, const_c2);
+ }
+
+ template< class Collection1, class Collection2 >
+ void test_for_each_impl()
+ {
+ test_for_each_impl< Collection1, Collection2 >(0);
+ test_for_each_impl< Collection1, Collection2 >(1);
+ test_for_each_impl< Collection1, Collection2 >(10);
+ }
+
+ void test_for_each()
+ {
+ test_for_each_impl< std::vector<int>, std::vector<int> >();
+ test_for_each_impl< std::list<int>, std::list<int> >();
+ test_for_each_impl< std::vector<int>, std::list<int> >();
+ test_for_each_impl< std::list<int>, std::vector<int> >();
+ }
+}
+
+boost::unit_test::test_suite*
+init_unit_test_suite(int argc, char* argv[])
+{
+ boost::unit_test::test_suite* test
+ = BOOST_TEST_SUITE( "RangeTestSuite.algorithm_ext.for_each" );
+
+ test->add( BOOST_TEST_CASE( &test_for_each ) );
+
+ return test;
+}
Added: trunk/libs/range/test/algorithm_ext_test/insert.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/range/test/algorithm_ext_test/insert.cpp 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -0,0 +1,72 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2010. Use, modification and
+// distribution is subject to 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)
+//
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#include <boost/range/algorithm_ext/insert.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <boost/range/iterator.hpp>
+#include <boost/range/irange.hpp>
+#include <algorithm>
+#include <list>
+#include <vector>
+
+namespace
+{
+ template< class Container >
+ void test_insert_impl( int n )
+ {
+ Container test;
+ boost::insert( test, test.end(), boost::irange(0, n) );
+
+ Container reference;
+ for (int i = 0; i < n; ++i)
+ reference.push_back(i);
+
+ BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+ test.begin(), test.end() );
+
+ // Do it again so that we are inserting into a non-empty target
+ boost::insert( test, test.end(), boost::irange(0, n) );
+
+ for (int j = 0; j < n; ++j)
+ reference.push_back(j);
+
+ BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+ test.begin(), test.end() );
+ }
+
+ template< class Container >
+ void test_insert_impl()
+ {
+ test_insert_impl< Container >(0);
+ test_insert_impl< Container >(1);
+ test_insert_impl< Container >(2);
+ test_insert_impl< Container >(100);
+ }
+
+ void test_insert()
+ {
+ test_insert_impl< std::vector<std::size_t> >();
+ test_insert_impl< std::list<std::size_t> >();
+ }
+}
+
+boost::unit_test::test_suite*
+init_unit_test_suite(int argc, char* argv[])
+{
+ boost::unit_test::test_suite* test
+ = BOOST_TEST_SUITE( "RangeTestSuite.algorithm_ext.insert" );
+
+ test->add( BOOST_TEST_CASE( &test_insert ) );
+
+ return test;
+}
Added: trunk/libs/range/test/algorithm_ext_test/iota.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/range/test/algorithm_ext_test/iota.cpp 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -0,0 +1,70 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2010. Use, modification and
+// distribution is subject to 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)
+//
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#include <boost/range/algorithm_ext/iota.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <boost/range/iterator.hpp>
+#include <algorithm>
+#include <list>
+#include <vector>
+
+namespace
+{
+ template< class Container >
+ void test_iota_impl(std::size_t n)
+ {
+ Container test;
+ test.resize( n );
+ boost::iota( test, n );
+
+ Container reference;
+ reference.resize( n );
+ std::size_t i = n;
+ typedef BOOST_DEDUCED_TYPENAME Container::iterator iterator_t;
+ iterator_t last = reference.end();
+ for (iterator_t it = reference.begin(); it != last; ++it, ++i)
+ {
+ *it = i;
+ }
+
+ BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+ test.begin(), test.end() );
+
+ }
+
+ template< class Container >
+ void test_iota_impl()
+ {
+ test_iota_impl< Container >(0);
+ test_iota_impl< Container >(1);
+ test_iota_impl< Container >(2);
+ test_iota_impl< Container >(100);
+ }
+
+ void test_iota()
+ {
+ test_iota_impl< std::vector<std::size_t> >();
+ test_iota_impl< std::list<std::size_t> >();
+ }
+}
+
+boost::unit_test::test_suite*
+init_unit_test_suite(int argc, char* argv[])
+{
+ boost::unit_test::test_suite* test
+ = BOOST_TEST_SUITE( "RangeTestSuite.algorithm_ext.iota" );
+
+ test->add( BOOST_TEST_CASE( &test_iota ) );
+
+ return test;
+}
Added: trunk/libs/range/test/algorithm_ext_test/is_sorted.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/range/test/algorithm_ext_test/is_sorted.cpp 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -0,0 +1,62 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2010. Use, modification and
+// distribution is subject to 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)
+//
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#include <boost/range/algorithm_ext/is_sorted.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <boost/range/iterator.hpp>
+#include <algorithm>
+#include <list>
+#include <vector>
+
+namespace
+{
+ template< class Container >
+ void test_is_sorted_impl()
+ {
+ Container ascending;
+ Container descending;
+
+ // Empty ranges are regarded as sorted against any predicate.
+ BOOST_CHECK( boost::is_sorted(ascending) );
+ BOOST_CHECK( boost::is_sorted(ascending, std::less<std::size_t>()) );
+ BOOST_CHECK( boost::is_sorted(ascending, std::greater<std::size_t>()) );
+
+ for (std::size_t i = 0; i < 10; ++i)
+ {
+ ascending.push_back(i);
+ descending.push_back(9 - i);
+ }
+
+ BOOST_CHECK( boost::is_sorted(ascending) );
+ BOOST_CHECK( !boost::is_sorted(descending) );
+ BOOST_CHECK( !boost::is_sorted(ascending, std::greater<std::size_t>()) );
+ BOOST_CHECK( boost::is_sorted(descending, std::greater<std::size_t>()) );
+ }
+
+ void test_is_sorted()
+ {
+ test_is_sorted_impl< std::vector<std::size_t> >();
+ test_is_sorted_impl< std::list<std::size_t> >();
+ }
+}
+
+boost::unit_test::test_suite*
+init_unit_test_suite(int argc, char* argv[])
+{
+ boost::unit_test::test_suite* test
+ = BOOST_TEST_SUITE( "RangeTestSuite.algorithm_ext.is_sorted" );
+
+ test->add( BOOST_TEST_CASE( &test_is_sorted ) );
+
+ return test;
+}
Added: trunk/libs/range/test/algorithm_ext_test/overwrite.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/range/test/algorithm_ext_test/overwrite.cpp 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -0,0 +1,74 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2010. Use, modification and
+// distribution is subject to 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)
+//
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#include <boost/range/algorithm_ext/overwrite.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <boost/range/iterator.hpp>
+#include <algorithm>
+#include <list>
+#include <vector>
+
+namespace
+{
+ template< class Container >
+ void test_overwrite_impl(std::size_t n)
+ {
+ Container overwrite_source;
+ for (std::size_t i = 0; i < n; ++i)
+ overwrite_source.push_back(i);
+
+ Container reference;
+ reference.resize(n);
+ std::copy(overwrite_source.begin(), overwrite_source.end(), reference.begin());
+
+ Container test;
+ test.resize(n);
+ boost::overwrite(overwrite_source, test);
+
+ BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+ test.begin(), test.end() );
+
+ test.clear();
+ test.resize(n);
+ const Container& const_overwrite_source = overwrite_source;
+ boost::overwrite(const_overwrite_source, test);
+
+ BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+ test.begin(), test.end() );
+ }
+
+ template< class Container >
+ void test_overwrite_impl()
+ {
+ test_overwrite_impl<Container>(0);
+ test_overwrite_impl<Container>(1);
+ test_overwrite_impl<Container>(10);
+ }
+
+ void test_overwrite()
+ {
+ test_overwrite_impl< std::vector<std::size_t> >();
+ test_overwrite_impl< std::list<std::size_t> >();
+ }
+}
+
+boost::unit_test::test_suite*
+init_unit_test_suite(int argc, char* argv[])
+{
+ boost::unit_test::test_suite* test
+ = BOOST_TEST_SUITE( "RangeTestSuite.algorithm_ext.overwrite" );
+
+ test->add( BOOST_TEST_CASE( &test_overwrite ) );
+
+ return test;
+}
Added: trunk/libs/range/test/algorithm_ext_test/push_back.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/range/test/algorithm_ext_test/push_back.cpp 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -0,0 +1,72 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2010. Use, modification and
+// distribution is subject to 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)
+//
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#include <boost/range/algorithm_ext/push_back.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <boost/range/iterator.hpp>
+#include <boost/range/irange.hpp>
+#include <algorithm>
+#include <list>
+#include <vector>
+
+namespace
+{
+ template< class Container >
+ void test_push_back_impl(std::size_t n)
+ {
+ Container reference;
+ for (std::size_t i = 0; i < n; ++i)
+ reference.push_back(i);
+
+ Container test;
+ boost::push_back(test, boost::irange<std::size_t>(0, n));
+
+ BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+ test.begin(), test.end() );
+
+ // Do it again to push onto non-empty container
+ for (std::size_t j = 0; j < n; ++j)
+ reference.push_back(j);
+
+ boost::push_back(test, boost::irange<std::size_t>(0, n));
+
+ BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+ test.begin(), test.end() );
+ }
+
+ template< class Container >
+ void test_push_back_impl()
+ {
+ test_push_back_impl< Container >(0);
+ test_push_back_impl< Container >(1);
+ test_push_back_impl< Container >(2);
+ test_push_back_impl< Container >(100);
+ }
+
+ void test_push_back()
+ {
+ test_push_back_impl< std::vector<std::size_t> >();
+ test_push_back_impl< std::list<std::size_t> >();
+ }
+}
+
+boost::unit_test::test_suite*
+init_unit_test_suite(int argc, char* argv[])
+{
+ boost::unit_test::test_suite* test
+ = BOOST_TEST_SUITE( "RangeTestSuite.algorithm_ext.push_back" );
+
+ test->add( BOOST_TEST_CASE( &test_push_back ) );
+
+ return test;
+}
Added: trunk/libs/range/test/algorithm_ext_test/push_front.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/range/test/algorithm_ext_test/push_front.cpp 2010-04-04 10:14:12 EDT (Sun, 04 Apr 2010)
@@ -0,0 +1,71 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2010. Use, modification and
+// distribution is subject to 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)
+//
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#include <boost/range/algorithm_ext/push_front.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <boost/range/iterator.hpp>
+#include <boost/range/irange.hpp>
+#include <algorithm>
+#include <list>
+#include <vector>
+
+namespace
+{
+ template< class Container >
+ void test_push_front_impl(std::size_t n)
+ {
+ Container reference;
+ for (std::size_t i = 0; i < n; ++i)
+ reference.push_back(i);
+
+ Container test;
+ boost::push_front(test, boost::irange<std::size_t>(0, n));
+
+ BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+ test.begin(), test.end() );
+
+ // Do it again to push onto non-empty container
+ reference.insert(reference.begin(), reference.begin(), reference.end());
+
+ boost::push_front(test, boost::irange<std::size_t>(0, n));
+
+ BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+ test.begin(), test.end() );
+ }
+
+ template< class Container >
+ void test_push_front_impl()
+ {
+ test_push_front_impl< Container >(0);
+ test_push_front_impl< Container >(1);
+ test_push_front_impl< Container >(2);
+ test_push_front_impl< Container >(100);
+ }
+
+ void test_push_front()
+ {
+ test_push_front_impl< std::vector<std::size_t> >();
+ test_push_front_impl< std::list<std::size_t> >();
+ }
+}
+
+boost::unit_test::test_suite*
+init_unit_test_suite(int argc, char* argv[])
+{
+ boost::unit_test::test_suite* test
+ = BOOST_TEST_SUITE( "RangeTestSuite.algorithm_ext.push_front" );
+
+ test->add( BOOST_TEST_CASE( &test_push_front ) );
+
+ return test;
+}