Subject: [Boost-commit] svn:boost r72427 - in branches/release: boost/range boost/range/adaptor boost/range/algorithm boost/range/algorithm_ext boost/range/detail libs/range libs/range/doc/reference/adaptors/examples libs/range/test libs/range/test/adaptor_test libs/range/test/compile_fail libs/range/test/test_driver
From: neil_at_[hidden]
Date: 2011-06-05 17:48:00
Author: neilgroves
Date: 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
New Revision: 72427
URL: http://svn.boost.org/trac/boost/changeset/72427
Log:
[boost][range] - merge from trunk of miscellaneous defect fixes
Added:
branches/release/libs/range/test/compile_fail/
- copied from r70855, /trunk/libs/range/test/compile_fail/
branches/release/libs/range/test/compile_fail/iterator_range1.cpp
- copied unchanged from r70855, /trunk/libs/range/test/compile_fail/iterator_range1.cpp
branches/release/libs/range/test/ticket_5486.cpp
- copied unchanged from r72177, /trunk/libs/range/test/ticket_5486.cpp
branches/release/libs/range/test/ticket_5544_terminate_irange.cpp
- copied unchanged from r72076, /trunk/libs/range/test/ticket_5544_terminate_irange.cpp
branches/release/libs/range/test/ticket_5547.cpp
- copied unchanged from r72177, /trunk/libs/range/test/ticket_5547.cpp
branches/release/libs/range/test/ticket_5556_is_sorted_namespace.cpp
- copied unchanged from r72177, /trunk/libs/range/test/ticket_5556_is_sorted_namespace.cpp
Properties modified:
branches/release/boost/range/ (props changed)
branches/release/libs/range/ (props changed)
Text files modified:
branches/release/boost/range/adaptor/adjacent_filtered.hpp | 4 -
branches/release/boost/range/adaptor/define_adaptor.hpp | 18 -----
branches/release/boost/range/adaptor/strided.hpp | 43 ++++++-------
branches/release/boost/range/adaptor/transformed.hpp | 4
branches/release/boost/range/algorithm/for_each.hpp | 66 ++++++++++++++++++++
branches/release/boost/range/algorithm_ext/is_sorted.hpp | 42 ++++---------
branches/release/boost/range/any_range.hpp | 1
branches/release/boost/range/detail/demote_iterator_traversal_tag.hpp | 16 ++++
branches/release/boost/range/detail/detail_str.hpp | 4
branches/release/boost/range/detail/join_iterator.hpp | 30 +++++++++
branches/release/boost/range/has_range_iterator.hpp | 2
branches/release/boost/range/irange.hpp | 18 ++--
branches/release/boost/range/iterator_range_core.hpp | 100 +++++++++++++++++++++++++++++++
branches/release/boost/range/join.hpp | 8 ++
branches/release/boost/range/sub_range.hpp | 51 ++++++++--------
branches/release/libs/range/doc/reference/adaptors/examples/adjacent_filtered.cpp | 2
branches/release/libs/range/doc/reference/adaptors/examples/indexed.cpp | 2
branches/release/libs/range/doc/reference/adaptors/examples/transformed.cpp | 2
branches/release/libs/range/test/Jamfile.v2 | 20 ++++++
branches/release/libs/range/test/adaptor_test/strided.cpp | 33 ++++++++++
branches/release/libs/range/test/irange.cpp | 58 +++++++++++++----
branches/release/libs/range/test/iterator_range.cpp | 124 +++++++++++++++++++++++++++++++++++++++
branches/release/libs/range/test/test_driver/range_return_test_driver.hpp | 5
23 files changed, 512 insertions(+), 141 deletions(-)
Modified: branches/release/boost/range/adaptor/adjacent_filtered.hpp
==============================================================================
--- branches/release/boost/range/adaptor/adjacent_filtered.hpp (original)
+++ branches/release/boost/range/adaptor/adjacent_filtered.hpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -143,10 +143,6 @@
skip_iter(boost::end(r), boost::end(r), p))
{
}
-
- private:
- P m_pred;
- R* m_range;
};
template< class T >
Modified: branches/release/boost/range/adaptor/define_adaptor.hpp
==============================================================================
--- branches/release/boost/range/adaptor/define_adaptor.hpp (original)
+++ branches/release/boost/range/adaptor/define_adaptor.hpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -44,24 +44,6 @@
return range_adaptor <const Range>(rng); \
}
-#define BOOST_DEFINE_RANGE_ADAPTOR_1( adaptor_name, range_adaptor, adaptor_class ) \
- template<typename Range> range_adaptor <Range> \
- operator|(Range& rng, const adaptor_name & args) \
- { \
- return range_adaptor <Range>(rng, args.arg1); \
- } \
- template<typename Range> range_adaptor <const Range> \
- operator|(const Range& rng, const adaptor_name & args) \
- { \
- return range_adaptor <Range>(rng, args.arg1); \
- } \
- template<typename Range, typename Arg1> \
- range_adaptor<Range> \
- make_##adaptor_name(Range& rng, Arg1 arg1) \
- { \
- return range_adaptor<Range>(rng, arg1); \
- }
-
#define BOOST_DEFINE_RANGE_ADAPTOR_1( adaptor_name, range_adaptor, arg1_type ) \
struct adaptor_name \
{ \
Modified: branches/release/boost/range/adaptor/strided.hpp
==============================================================================
--- branches/release/boost/range/adaptor/strided.hpp (original)
+++ branches/release/boost/range/adaptor/strided.hpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -176,6 +176,7 @@
strided_iterator()
: m_first()
, m_last()
+ , m_index(0)
, m_stride()
{
}
@@ -184,6 +185,7 @@
: super_t(it)
, m_first(first)
, m_last(last)
+ , m_index(stride ? (it - first) / stride : 0)
, m_stride(stride)
{
}
@@ -194,6 +196,7 @@
: super_t(other.base())
, m_first(other.base_begin())
, m_last(other.base_end())
+ , m_index(other.get_index())
, m_stride(other.get_stride())
{
}
@@ -201,44 +204,37 @@
base_iterator base_begin() const { return m_first; }
base_iterator base_end() const { return m_last; }
difference_type get_stride() const { return m_stride; }
+ difference_type get_index() const { return m_index; }
private:
void increment()
{
- base_iterator& it = this->base_reference();
- if ((m_last - it) > m_stride)
- it += m_stride;
+ m_index += m_stride;
+ if (m_index < (m_last - m_first))
+ this->base_reference() = m_first + m_index;
else
- it = m_last;
+ this->base_reference() = m_last;
}
void decrement()
{
- base_iterator& it = this->base_reference();
- if ((it - m_first) > m_stride)
- it -= m_stride;
+ m_index -= m_stride;
+ if (m_index >= 0)
+ this->base_reference() = m_first + m_index;
else
- it = m_first;
+ this->base_reference() = m_first;
}
void advance(difference_type offset)
{
- base_iterator& it = this->base_reference();
offset *= m_stride;
- if (offset >= 0)
- {
- if ((m_last - it) > offset)
- it += offset;
- else
- it = m_last;
- }
+ m_index += offset;
+ if (m_index < 0)
+ this->base_reference() = m_first;
+ else if (m_index > (m_last - m_first))
+ this->base_reference() = m_last;
else
- {
- if ((m_first - it) > offset)
- it += offset;
- else
- it = m_first;
- }
+ this->base_reference() = m_first + m_index;
}
template<class OtherIterator>
@@ -252,12 +248,13 @@
bool equal(const strided_iterator& other) const
{
- return other.base() == this->base();
+ return this->base() == other.base();
}
private:
base_iterator m_first;
base_iterator m_last;
+ difference_type m_index;
difference_type m_stride;
};
Modified: branches/release/boost/range/adaptor/transformed.hpp
==============================================================================
--- branches/release/boost/range/adaptor/transformed.hpp (original)
+++ branches/release/boost/range/adaptor/transformed.hpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -42,8 +42,8 @@
typedef R source_range_type;
transformed_range( F f, R& r )
- : base( make_transform_iterator( boost::begin(r), f ),
- make_transform_iterator( boost::end(r), f ) )
+ : base( boost::make_transform_iterator( boost::begin(r), f ),
+ boost::make_transform_iterator( boost::end(r), f ) )
{ }
};
Modified: branches/release/boost/range/algorithm/for_each.hpp
==============================================================================
--- branches/release/boost/range/algorithm/for_each.hpp (original)
+++ branches/release/boost/range/algorithm/for_each.hpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -13,13 +13,53 @@
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/range/concepts.hpp>
+#include <boost/ref.hpp>
+#include <boost/utility.hpp>
#include <algorithm>
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1600)
+#include <xutility>
+#endif
+
namespace boost
{
namespace range
{
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1600)
+ namespace for_each_detail
+ {
+ template<typename Iterator, typename UnaryFunction>
+ inline UnaryFunction
+ for_each_impl(Iterator first, Iterator last, UnaryFunction fun,
+ typename enable_if<
+ is_reference_wrapper<UnaryFunction>,
+ void
+ >::type* = 0)
+ {
+ typedef typename std::_Get_unchecked_type<Iterator>::type
+ unchecked_iterator;
+
+ unchecked_iterator unchecked_last = std::_Unchecked(last);
+ for (unchecked_iterator unchecked_first = std::_Unchecked(first); first != last; ++first)
+ fun.get()(*unchecked_first);
+
+ return fun;
+ }
+
+ template<typename Iterator, typename UnaryFunction>
+ inline UnaryFunction
+ for_each_impl(Iterator first, Iterator last, UnaryFunction fn,
+ typename disable_if<
+ is_reference_wrapper<UnaryFunction>,
+ void
+ >::type* = 0)
+ {
+ return std::for_each<Iterator, UnaryFunction>(first, last, fn);
+ }
+ }
+#endif
+
/// \brief template function for_each
///
/// range-based version of the for_each std algorithm
@@ -30,7 +70,18 @@
inline UnaryFunction for_each(SinglePassRange & rng, UnaryFunction fun)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
- return std::for_each(boost::begin(rng),boost::end(rng),fun);
+
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1600)
+ return for_each_detail::for_each_impl<
+ typename range_iterator<SinglePassRange>::type,
+ UnaryFunction
+ >(boost::begin(rng), boost::end(rng), fun);
+#else
+ return std::for_each<
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type,
+ UnaryFunction
+ >(boost::begin(rng),boost::end(rng),fun);
+#endif
}
/// \overload
@@ -38,7 +89,18 @@
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);
+
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1600)
+ return for_each_detail::for_each_impl<
+ typename range_iterator<const SinglePassRange>::type,
+ UnaryFunction
+ >(boost::begin(rng), boost::end(rng), fun);
+#else
+ return std::for_each<
+ BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type,
+ UnaryFunction
+ >(boost::begin(rng), boost::end(rng), fun);
+#endif
}
} // namespace range
Modified: branches/release/boost/range/algorithm_ext/is_sorted.hpp
==============================================================================
--- branches/release/boost/range/algorithm_ext/is_sorted.hpp (original)
+++ branches/release/boost/range/algorithm_ext/is_sorted.hpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -1,3 +1,4 @@
+// Copyright Bryce Lelbach 2010
// 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
@@ -14,45 +15,26 @@
#include <boost/range/end.hpp>
#include <boost/range/concepts.hpp>
#include <boost/range/value_type.hpp>
+#include <boost/detail/is_sorted.hpp>
#include <algorithm>
namespace boost
{
- namespace range_detail
- {
- template<class ForwardIterator>
- inline bool is_sorted(ForwardIterator first, ForwardIterator last)
- {
- for (ForwardIterator next = first; first != last && ++next != last; ++first)
- if (*next < *first)
- return false;
- return true;
- }
-
- template<class ForwardIterator, class BinaryPredicate>
- inline bool is_sorted(ForwardIterator first, ForwardIterator last, BinaryPredicate pred)
- {
- for (ForwardIterator next = first; first != last && ++next != last; ++first)
- if (pred(*next, *first))
- return false;
- return true;
- }
- }
-
namespace range
{
-/// \brief template function count
+/// \brief template function is_sorted
///
-/// range-based version of the count std algorithm
+/// range-based version of the is_sorted 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<const SinglePassRange>::type>));
- return range_detail::is_sorted(boost::begin(rng), boost::end(rng));
+ BOOST_RANGE_CONCEPT_ASSERT((LessThanComparableConcept<BOOST_DEDUCED_TYPENAME
+ range_value<const SinglePassRange>::type>));
+ return ::boost::detail::is_sorted(boost::begin(rng), boost::end(rng));
}
/// \overload
@@ -60,12 +42,16 @@
inline bool is_sorted(const SinglePassRange& rng, BinaryPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange>));
- BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type, BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type>));
- return range_detail::is_sorted(boost::begin(rng), boost::end(rng), pred);
+ BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type,
+ BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type>));
+ return ::boost::detail::is_sorted(boost::begin(rng), boost::end(rng), pred);
}
} // namespace range
- using range::is_sorted;
+
+using range::is_sorted;
+
} // namespace boost
#endif // include guard
Modified: branches/release/boost/range/any_range.hpp
==============================================================================
--- branches/release/boost/range/any_range.hpp (original)
+++ branches/release/boost/range/any_range.hpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -15,6 +15,7 @@
#include <boost/iterator/iterator_facade.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/range/detail/any_iterator.hpp>
+#include <boost/range/concepts.hpp>
#include <boost/range/reference.hpp>
#include <boost/range/value_type.hpp>
#include <boost/range/iterator_range_core.hpp>
Modified: branches/release/boost/range/detail/demote_iterator_traversal_tag.hpp
==============================================================================
--- branches/release/boost/range/detail/demote_iterator_traversal_tag.hpp (original)
+++ branches/release/boost/range/detail/demote_iterator_traversal_tag.hpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -5,6 +5,9 @@
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
+// Acknowledgements:
+// aschoedl supplied a fix to supply the level of interoperability I had
+// originally intended, but failed to implement.
//
// For more information, see http://www.boost.org/libs/range/
//
@@ -19,12 +22,12 @@
{
template<class IteratorTraversalTag1, class IteratorTraversalTag2>
-struct demote_iterator_traversal_tag
+struct inner_demote_iterator_traversal_tag
{
};
#define BOOST_DEMOTE_TRAVERSAL_TAG( Tag1, Tag2, ResultTag ) \
-template<> struct demote_iterator_traversal_tag< Tag1 , Tag2 > \
+template<> struct inner_demote_iterator_traversal_tag< Tag1 , Tag2 > \
{ \
typedef ResultTag type; \
};
@@ -73,6 +76,15 @@
#undef BOOST_DEMOTE_TRAVERSAL_TAG
+template<class IteratorTraversalTag1, class IteratorTraversalTag2>
+struct demote_iterator_traversal_tag
+ : inner_demote_iterator_traversal_tag<
+ typename boost::detail::pure_traversal_tag< IteratorTraversalTag1 >::type,
+ typename boost::detail::pure_traversal_tag< IteratorTraversalTag2 >::type
+ >
+{
+};
+
} // namespace range_detail
} // namespace boost
Modified: branches/release/boost/range/detail/detail_str.hpp
==============================================================================
--- branches/release/boost/range/detail/detail_str.hpp (original)
+++ branches/release/boost/range/detail/detail_str.hpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -134,8 +134,8 @@
#include <boost/range/detail/begin.hpp>
#include <boost/range/detail/end.hpp>
-#include <boost/range/detail/size_type>
-#include <boost/range/detail/value_type>
+#include <boost/range/detail/size_type.hpp>
+#include <boost/range/detail/value_type.hpp>
#include <boost/range/detail/common.hpp>
namespace boost
Modified: branches/release/boost/range/detail/join_iterator.hpp
==============================================================================
--- branches/release/boost/range/detail/join_iterator.hpp (original)
+++ branches/release/boost/range/detail/join_iterator.hpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -5,6 +5,9 @@
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
+// Acknowledgements:
+// aschoedl contributed an improvement to the determination
+// of the Reference type parameter.
//
// For more information, see http://www.boost.org/libs/range/
//
@@ -120,7 +123,32 @@
template<typename Iterator1
, typename Iterator2
, typename ValueType = typename iterator_value<Iterator1>::type
- , typename Reference = typename iterator_reference<Iterator1>::type
+ // find least demanding, commonly supported reference type, in the order &, const&, and by-value:
+ , typename Reference = typename mpl::if_c<
+ !is_reference<typename iterator_reference<Iterator1>::type>::value
+ || !is_reference<typename iterator_reference<Iterator2>::type>::value,
+ typename remove_const<
+ typename remove_reference<
+ typename iterator_reference<Iterator1>::type
+ >::type
+ >::type,
+ typename mpl::if_c<
+ is_const<
+ typename remove_reference<
+ typename iterator_reference<Iterator1>::type
+ >::type
+ >::value
+ || is_const<
+ typename remove_reference<
+ typename iterator_reference<Iterator2>::type
+ >::type
+ >::value,
+ typename add_const<
+ typename iterator_reference<Iterator2>::type
+ >::type,
+ typename iterator_reference<Iterator1>::type
+ >::type
+ >::type
, typename Traversal = typename demote_iterator_traversal_tag<
typename iterator_traversal<Iterator1>::type
, typename iterator_traversal<Iterator2>::type>::type
Modified: branches/release/boost/range/has_range_iterator.hpp
==============================================================================
--- branches/release/boost/range/has_range_iterator.hpp (original)
+++ branches/release/boost/range/has_range_iterator.hpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -19,7 +19,7 @@
{
namespace range_detail
{
- BOOST_MPL_HAS_XXX_TRAIT_DEF(type);
+ BOOST_MPL_HAS_XXX_TRAIT_DEF(type)
template<class T, class Enabler = void>
struct has_range_iterator_impl
Modified: branches/release/boost/range/irange.hpp
==============================================================================
--- branches/release/boost/range/irange.hpp (original)
+++ branches/release/boost/range/irange.hpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -124,13 +124,11 @@
typedef typename base_t::difference_type difference_type;
typedef typename base_t::reference reference;
- integer_iterator_with_step(value_type first, value_type step, difference_type step_size)
+ integer_iterator_with_step(value_type first, difference_type step, value_type step_size)
: m_first(first)
, m_step(step)
, m_step_size(step_size)
{
- BOOST_ASSERT( step >= 0 );
- BOOST_ASSERT( step_size != 0 );
}
private:
@@ -213,16 +211,18 @@
{
BOOST_ASSERT( step_size != 0 );
BOOST_ASSERT( (step_size > 0) ? (last >= first) : (last <= first) );
-
+
typedef typename range_detail::integer_iterator_with_step<Integer> iterator_t;
- const std::ptrdiff_t last_step
- = (static_cast<std::ptrdiff_t>(last) - static_cast<std::ptrdiff_t>(first))
- / (static_cast<std::ptrdiff_t>(step_size));
-
+ const std::ptrdiff_t sz = static_cast<std::ptrdiff_t>(step_size >= 0 ? step_size : -step_size);
+ const Integer l = step_size >= 0 ? last : first;
+ const Integer f = step_size >= 0 ? first : last;
+ const std::ptrdiff_t num_steps = (l + ((l-f) % sz) - f) / sz;
+ BOOST_ASSERT(num_steps >= 0);
+
return strided_integer_range<Integer>(
iterator_t(first, 0, step_size),
- iterator_t(first, last_step, step_size));
+ iterator_t(first, num_steps, step_size));
}
} // namespace boost
Modified: branches/release/boost/range/iterator_range_core.hpp
==============================================================================
--- branches/release/boost/range/iterator_range_core.hpp (original)
+++ branches/release/boost/range/iterator_range_core.hpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -53,13 +53,13 @@
template< class ForwardRange >
static IteratorT adl_begin( ForwardRange& r )
{
- return IteratorT( boost::begin( r ) );
+ return static_cast<IteratorT>( boost::begin( r ) );
}
template< class ForwardRange >
static IteratorT adl_end( ForwardRange& r )
{
- return IteratorT( boost::end( r ) );
+ return static_cast<IteratorT>( boost::end( r ) );
}
};
@@ -71,6 +71,24 @@
boost::begin(r),
boost::end(r) );
}
+
+ template< class Left, class Right >
+ inline bool greater_than( const Left& l, const Right& r )
+ {
+ return less_than(r,l);
+ }
+
+ template< class Left, class Right >
+ inline bool less_or_equal_than( const Left& l, const Right& r )
+ {
+ return !iterator_range_detail::less_than(r,l);
+ }
+
+ template< class Left, class Right >
+ inline bool greater_or_equal_than( const Left& l, const Right& r )
+ {
+ return !iterator_range_detail::less_than(l,r);
+ }
// This version is maintained since it is used in other boost libraries
// such as Boost.Assign
@@ -271,6 +289,21 @@
{
return iterator_range_detail::less_than( *this, r );
}
+
+ bool operator>( const iterator_range& r ) const
+ {
+ return iterator_range_detail::greater_than( *this, r );
+ }
+
+ bool operator<=( const iterator_range& r ) const
+ {
+ return iterator_range_detail::less_or_equal_than( *this, r );
+ }
+
+ bool operator>=( const iterator_range& r ) const
+ {
+ return iterator_range_detail::greater_or_equal_than( *this, r );
+ }
#endif
@@ -370,6 +403,27 @@
{
return iterator_range_detail::less_than( l, r );
}
+
+ template< class IteratorT, class ForwardRange >
+ inline bool operator<=( const ForwardRange& l,
+ const iterator_range<IteratorT>& r )
+ {
+ return iterator_range_detail::less_or_equal_than( l, r );
+ }
+
+ template< class IteratorT, class ForwardRange >
+ inline bool operator>( const ForwardRange& l,
+ const iterator_range<IteratorT>& r )
+ {
+ return iterator_range_detail::greater_than( l, r );
+ }
+
+ template< class IteratorT, class ForwardRange >
+ inline bool operator>=( const ForwardRange& l,
+ const iterator_range<IteratorT>& r )
+ {
+ return iterator_range_detail::greater_or_equal_than( l, r );
+ }
#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
#else
@@ -416,6 +470,48 @@
{
return iterator_range_detail::less_than( l, r );
}
+
+ template< class Iterator1T, class Iterator2T >
+ inline bool operator<=( const iterator_range<Iterator1T>& l,
+ const iterator_range<Iterator2T>& r )
+ {
+ return iterator_range_detail::less_or_equal_than( l, r );
+ }
+
+ template< class IteratorT, class ForwardRange >
+ inline bool operator<=( const iterator_range<IteratorT>& l,
+ const ForwardRange& r )
+ {
+ return iterator_range_detail::less_or_equal_than( l, r );
+ }
+
+ template< class Iterator1T, class Iterator2T >
+ inline bool operator>( const iterator_range<Iterator1T>& l,
+ const iterator_range<Iterator2T>& r )
+ {
+ return iterator_range_detail::greater_than( l, r );
+ }
+
+ template< class IteratorT, class ForwardRange >
+ inline bool operator>( const iterator_range<IteratorT>& l,
+ const ForwardRange& r )
+ {
+ return iterator_range_detail::greater_than( l, r );
+ }
+
+ template< class Iterator1T, class Iterator2T >
+ inline bool operator>=( const iterator_range<Iterator1T>& l,
+ const iterator_range<Iterator2T>& r )
+ {
+ return iterator_range_detail::greater_or_equal_than( l, r );
+ }
+
+ template< class IteratorT, class ForwardRange >
+ inline bool operator>=( const iterator_range<IteratorT>& l,
+ const ForwardRange& r )
+ {
+ return iterator_range_detail::greater_or_equal_than( l, r );
+ }
#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
Modified: branches/release/boost/range/join.hpp
==============================================================================
--- branches/release/boost/range/join.hpp (original)
+++ branches/release/boost/range/join.hpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -36,6 +36,9 @@
} // namespace range_detail
+namespace range
+{
+
template<class SinglePassRange1, class SinglePassRange2>
class joined_range
: public range_detail::joined_type<SinglePassRange1, SinglePassRange2>::type
@@ -78,6 +81,11 @@
return joined_range<SinglePassRange1, SinglePassRange2>(r1, r2);
}
+} // namespace range
+
+using ::boost::range::joined_range;
+using ::boost::range::join;
+
} // namespace boost
#endif // include guard
Modified: branches/release/boost/range/sub_range.hpp
==============================================================================
--- branches/release/boost/range/sub_range.hpp (original)
+++ branches/release/boost/range/sub_range.hpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -12,12 +12,13 @@
#ifndef BOOST_RANGE_SUB_RANGE_HPP
#define BOOST_RANGE_SUB_RANGE_HPP
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+#include <boost/detail/workaround.hpp>
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
#pragma warning( push )
#pragma warning( disable : 4996 )
#endif
-#include <boost/detail/workaround.hpp>
#include <boost/range/config.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/range/value_type.hpp>
@@ -30,9 +31,9 @@
namespace boost
{
-
- template< class ForwardRange >
- class sub_range : public iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >
+
+ template< class ForwardRange >
+ class sub_range : public iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >
{
typedef BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type iterator_t;
typedef iterator_range< iterator_t > base;
@@ -53,40 +54,40 @@
reference >::type const_reference;
public:
- sub_range() : base()
- { }
-
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500) )
- sub_range( const sub_range& r )
- : base( static_cast<const base&>( r ) )
+ sub_range() : base()
{ }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500) )
+ sub_range( const sub_range& r )
+ : base( static_cast<const base&>( r ) )
+ { }
#endif
template< class ForwardRange2 >
- sub_range( ForwardRange2& r ) :
-
+ sub_range( ForwardRange2& r ) :
+
#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 )
base( impl::adl_begin( r ), impl::adl_end( r ) )
#else
base( r )
-#endif
+#endif
{ }
-
+
template< class ForwardRange2 >
- sub_range( const ForwardRange2& r ) :
+ sub_range( const ForwardRange2& r ) :
#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 )
base( impl::adl_begin( r ), impl::adl_end( r ) )
#else
base( r )
-#endif
+#endif
{ }
template< class Iter >
sub_range( Iter first, Iter last ) :
base( first, last )
{ }
-
+
template< class ForwardRange2 >
sub_range& operator=( ForwardRange2& r )
{
@@ -99,23 +100,23 @@
{
base::operator=( r );
return *this;
- }
+ }
sub_range& operator=( const sub_range& r )
{
base::operator=( static_cast<const base&>(r) );
- return *this;
+ return *this;
}
-
+
public:
-
+
iterator begin() { return base::begin(); }
const_iterator begin() const { return base::begin(); }
iterator end() { return base::end(); }
const_iterator end() const { return base::end(); }
- difference_type size() const { return base::size(); }
-
+ difference_type size() const { return base::size(); }
+
public: // convenience
reference front()
{
@@ -173,7 +174,7 @@
} // namespace 'boost'
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
#pragma warning( pop )
#endif
Modified: branches/release/libs/range/doc/reference/adaptors/examples/adjacent_filtered.cpp
==============================================================================
--- branches/release/libs/range/doc/reference/adaptors/examples/adjacent_filtered.cpp (original)
+++ branches/release/libs/range/doc/reference/adaptors/examples/adjacent_filtered.cpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -11,7 +11,7 @@
#include <boost/range/algorithm/copy.hpp>
#include <boost/assign.hpp>
#include <algorithm>
-#include <functinoal>
+#include <functional>
#include <iostream>
#include <vector>
Modified: branches/release/libs/range/doc/reference/adaptors/examples/indexed.cpp
==============================================================================
--- branches/release/libs/range/doc/reference/adaptors/examples/indexed.cpp (original)
+++ branches/release/libs/range/doc/reference/adaptors/examples/indexed.cpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -41,5 +41,5 @@
display_element_and_index( input | indexed(0) );
return 0;
-]
+}
Modified: branches/release/libs/range/doc/reference/adaptors/examples/transformed.cpp
==============================================================================
--- branches/release/libs/range/doc/reference/adaptors/examples/transformed.cpp (original)
+++ branches/release/libs/range/doc/reference/adaptors/examples/transformed.cpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -9,7 +9,7 @@
//
#include <boost/range/adaptor/transformed.hpp>
#include <boost/range/algorithm/copy.hpp>
-#include <boost/range/assign.hpp>
+#include <boost/assign.hpp>
#include <algorithm>
#include <iostream>
#include <vector>
Modified: branches/release/libs/range/test/Jamfile.v2
==============================================================================
--- branches/release/libs/range/test/Jamfile.v2 (original)
+++ branches/release/libs/range/test/Jamfile.v2 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -31,6 +31,22 @@
}
test-suite range :
+ [ compile ../doc/reference/adaptors/examples/adjacent_filtered.cpp : : example_adjacent_filtered ]
+ [ compile ../doc/reference/adaptors/examples/copied.cpp : : example_copied ]
+ [ compile ../doc/reference/adaptors/examples/filtered.cpp : : example_filtered ]
+ [ compile ../doc/reference/adaptors/examples/indexed.cpp : : example_indexed ]
+ [ compile ../doc/reference/adaptors/examples/indirected.cpp : : example_indirected ]
+ [ compile ../doc/reference/adaptors/examples/map_keys.cpp : : example_map_keys ]
+ [ compile ../doc/reference/adaptors/examples/map_values.cpp : : example_map_values ]
+ [ compile ../doc/reference/adaptors/examples/replaced.cpp : : example_replaced ]
+ [ compile ../doc/reference/adaptors/examples/replaced_if.cpp : : example_replaced_if ]
+ [ compile ../doc/reference/adaptors/examples/reversed.cpp : : example_reversed ]
+ [ compile ../doc/reference/adaptors/examples/sliced.cpp : : example_sliced ]
+ [ compile ../doc/reference/adaptors/examples/strided.cpp : : example_strided ]
+ [ compile ../doc/reference/adaptors/examples/tokenized.cpp : : example_tokenized ]
+ [ compile ../doc/reference/adaptors/examples/transformed.cpp : : example_transformed ]
+ [ compile ../doc/reference/adaptors/examples/uniqued.cpp : : example_uniqued ]
+ [ compile-fail compile_fail/iterator_range1.cpp ]
[ range-test adaptor_test/adjacent_filtered ]
[ range-test adaptor_test/copied ]
[ range-test adaptor_test/filtered ]
@@ -155,5 +171,9 @@
[ range-test std_container ]
[ range-test string ]
[ range-test sub_range ]
+ [ range-test ticket_5486 ]
+ [ range-test ticket_5544_terminate_irange ]
+ [ range-test ticket_5547 ]
+ [ range-test ticket_5556_is_sorted_namespace ]
;
Modified: branches/release/libs/range/test/adaptor_test/strided.cpp
==============================================================================
--- branches/release/libs/range/test/adaptor_test/strided.cpp (original)
+++ branches/release/libs/range/test/adaptor_test/strided.cpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -250,6 +250,38 @@
BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
output.begin(), output.end() );
}
+
+ template<typename Range>
+ void strided_test_ticket_5236_check_bidirectional(const Range& rng)
+ {
+ BOOST_CHECK_EQUAL( boost::distance(rng), 1 );
+ BOOST_CHECK_EQUAL( std::distance(boost::begin(rng), boost::prior(boost::end(rng))), 0 );
+ }
+
+ template<typename Range>
+ void strided_test_ticket_5236_check(const Range& rng)
+ {
+ strided_test_ticket_5236_check_bidirectional(rng);
+
+ typename boost::range_iterator<const Range>::type it = boost::end(rng);
+ it = it - 1;
+ BOOST_CHECK_EQUAL( std::distance(boost::begin(rng), it), 0 );
+ }
+
+ void strided_test_ticket_5236()
+ {
+ std::vector<int> v;
+ v.push_back(1);
+ strided_test_ticket_5236_check( v | boost::adaptors::strided(2) );
+
+ // Ensure that there is consistency between the random-access implementation
+ // and the bidirectional.
+
+ std::list<int> l;
+ l.push_back(1);
+ strided_test_ticket_5236_check_bidirectional( l | boost::adaptors::strided(2) );
+ }
+
}
}
@@ -262,6 +294,7 @@
test->add( BOOST_TEST_CASE( &boost::strided_test ) );
test->add( BOOST_TEST_CASE( &boost::strided_defect_Trac5014 ) );
test->add( BOOST_TEST_CASE( &boost::strided_test_traversal ) );
+ test->add( BOOST_TEST_CASE( &boost::strided_test_ticket_5236 ) );
return test;
}
Modified: branches/release/libs/range/test/irange.cpp
==============================================================================
--- branches/release/libs/range/test/irange.cpp (original)
+++ branches/release/libs/range/test/irange.cpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -14,7 +14,6 @@
#include <boost/range/end.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
-#include <iostream>
#include <vector>
namespace boost
@@ -35,27 +34,38 @@
BOOST_CHECK_EQUAL_COLLECTIONS( test.begin(), test.end(),
reference.begin(), reference.end() );
}
+
+ template<typename Integer>
+ std::ptrdiff_t test_irange_calculate_num_steps(Integer first, Integer last, int step)
+ {
+ const std::ptrdiff_t sz = static_cast<std::ptrdiff_t>(step >= 0 ? step : -step);
+ const std::ptrdiff_t l = static_cast<std::ptrdiff_t>(step >= 0 ? last : first);
+ const std::ptrdiff_t f = static_cast<std::ptrdiff_t>(step >= 0 ? first : last);
+ return (l + ((l-f) % sz) - f) / sz;
+ }
// Test an integer range with a runtime specified step size.
- template<typename Integer>
- void test_irange_impl(Integer first, Integer last, int step)
+ template<typename Integer, typename IntegerInput>
+ void test_irange_impl(IntegerInput first, IntegerInput last, int step)
{
BOOST_ASSERT( step != 0 );
+
+ // Skip tests that have negative values if the type is
+ // unsigned
+ if ((static_cast<IntegerInput>(static_cast<Integer>(first)) != first)
+ || (static_cast<IntegerInput>(static_cast<Integer>(last)) != last))
+ return;
+
std::vector<Integer> reference;
- if (step > 0)
- {
- for (Integer i = first; i < last; i += step)
- reference.push_back(i);
- }
- else
- {
- for (Integer i = first; i > last; i += step)
- reference.push_back(i);
- }
+
+ const std::ptrdiff_t num_steps = test_irange_calculate_num_steps(first, last, step);
+ Integer current_value = first;
+ for (std::ptrdiff_t i = 0; i < num_steps; ++i, current_value += step)
+ reference.push_back(current_value);
std::vector<Integer> test;
boost::push_back(test, boost::irange(first, last, step));
-
+
BOOST_CHECK_EQUAL_COLLECTIONS( test.begin(), test.end(),
reference.begin(), reference.end() );
}
@@ -81,7 +91,6 @@
void test_irange(int first, int last, int step_size)
{
BOOST_ASSERT( step_size != 0 );
- BOOST_ASSERT( (last - first) % step_size == 0 );
test_irange_impl<signed char>(first, last, step_size);
test_irange_impl<unsigned char>(first, last, step_size);
test_irange_impl<signed short>(first, last, step_size);
@@ -114,8 +123,27 @@
test_irange(10, 0, -1);
test_irange(0, 2, 2);
test_irange(2, 0, -2);
+ test_irange(0, 9, 2);
+ test_irange(9, 0, -2);
+ test_irange(-9, 0, 2);
+ test_irange(-9, 9, 2);
+ test_irange(9, -9, -2);
test_irange(10, 20, 5);
test_irange(20, 10, -5);
+
+ test_irange(0, 0, 3);
+ test_irange(0, 1, 3);
+ test_irange(0, 2, 3);
+ test_irange(0, 3, 3);
+ test_irange(0, 4, 3);
+ test_irange(0, 10, 3);
+
+ test_irange(0, 0, -3);
+ test_irange(0, -1, -3);
+ test_irange(0, -2, -3);
+ test_irange(0, -3, -3);
+ test_irange(0, -4, -3);
+ test_irange(0, -10, -3);
}
} // namespace boost
Modified: branches/release/libs/range/test/iterator_range.cpp
==============================================================================
--- branches/release/libs/range/test/iterator_range.cpp (original)
+++ branches/release/libs/range/test/iterator_range.cpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -24,6 +24,7 @@
#include <boost/test/unit_test.hpp>
#include <iostream>
#include <string>
+#include <vector>
void check_reference_type();
@@ -102,17 +103,136 @@
check_reference_type();
}
+namespace iterator_range_test_detail
+{
+ struct less
+ {
+ template< class Left, class Right >
+ bool operator()(const Left& l, const Right& r) const
+ {
+ return l < r;
+ }
+ };
+
+ struct greater
+ {
+ template< class Left, class Right >
+ bool operator()(const Left& l, const Right& r) const
+ {
+ return l > r;
+ }
+ };
+
+ struct less_or_equal
+ {
+ template< class Left, class Right >
+ bool operator()(const Left& l, const Right& r) const
+ {
+ return l <= r;
+ }
+ };
+
+ struct greater_or_equal
+ {
+ template< class Left, class Right >
+ bool operator()(const Left& l, const Right& r) const
+ {
+ return l >= r;
+ }
+ };
+
+ struct equal_to
+ {
+ template< class Left, class Right >
+ bool operator()(const Left& l, const Right& r) const
+ {
+ return l == r;
+ }
+ };
+
+ struct not_equal_to
+ {
+ template< class Left, class Right >
+ bool operator()(const Left& l, const Right& r) const
+ {
+ return l != r;
+ }
+ };
+
+ template< class Pred >
+ void check_iterator_range_operators_impl(Pred pred)
+ {
+ std::vector<std::string> vals;
+ vals.push_back(std::string());
+ vals.push_back("a");
+ vals.push_back("b");
+ vals.push_back("z");
+ vals.push_back("ab");
+ vals.push_back("ba");
+ vals.push_back("abc");
+ vals.push_back("cba");
+ vals.push_back("aa");
+ vals.push_back("aaa");
+ vals.push_back("aab");
+ vals.push_back("bba");
+
+ typedef std::string::const_iterator citer;
+ typedef boost::iterator_range<citer> iter_range;
+
+ typedef std::vector<std::string>::const_iterator value_const_iterator;
+ value_const_iterator first_val = vals.begin();
+ value_const_iterator last_val = vals.end();
+
+ for (value_const_iterator left_it = first_val; left_it != last_val; ++left_it)
+ {
+ const std::string& leftValue = *left_it;
+ for (value_const_iterator right_it = first_val; right_it != last_val; ++right_it)
+ {
+ const std::string& rightValue = *right_it;
+ iter_range left = boost::make_iterator_range(leftValue);
+ iter_range right = boost::make_iterator_range(rightValue);
+
+ const bool reference = pred(leftValue, rightValue);
+
+ BOOST_CHECK_EQUAL( pred(left, right), reference );
+ BOOST_CHECK_EQUAL( pred(left, rightValue), reference );
+ BOOST_CHECK_EQUAL( pred(leftValue, right), reference );
+ }
+ }
+ }
+
+ void check_iterator_range_from_array()
+ {
+ double source[] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0 };
+ boost::iterator_range<double*> rng = boost::make_iterator_range(source);
+ BOOST_CHECK_EQUAL_COLLECTIONS( rng.begin(), rng.end(),
+ source, source + 6 );
+ }
+
+} // namespace iterator_range_test_detail
+
+template<typename Pred>
+inline void check_iterator_range_operator()
+{
+ iterator_range_test_detail::check_iterator_range_operators_impl(
+ Pred());
+}
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
boost::unit_test::test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
- test->add( BOOST_TEST_CASE( &check_iterator_range ) );
+ test->add(BOOST_TEST_CASE(&check_iterator_range));
+ test->add(BOOST_TEST_CASE(&check_iterator_range_operator<iterator_range_test_detail::less>));
+ test->add(BOOST_TEST_CASE(&check_iterator_range_operator<iterator_range_test_detail::less_or_equal>));
+ test->add(BOOST_TEST_CASE(&check_iterator_range_operator<iterator_range_test_detail::greater>));
+ test->add(BOOST_TEST_CASE(&check_iterator_range_operator<iterator_range_test_detail::greater_or_equal>));
+ test->add(BOOST_TEST_CASE(&check_iterator_range_operator<iterator_range_test_detail::equal_to>));
+ test->add(BOOST_TEST_CASE(&check_iterator_range_operator<iterator_range_test_detail::not_equal_to>));
return test;
}
-
//
//
// Check that constness is propgated correct from
Modified: branches/release/libs/range/test/test_driver/range_return_test_driver.hpp
==============================================================================
--- branches/release/libs/range/test/test_driver/range_return_test_driver.hpp (original)
+++ branches/release/libs/range/test/test_driver/range_return_test_driver.hpp 2011-06-05 17:47:57 EDT (Sun, 05 Jun 2011)
@@ -371,7 +371,7 @@
Container reference(cont);
Container test(cont);
-
+
iterator_t range_result = policy.test_iter(test);
iterator_t reference_it = policy.reference(reference);
@@ -391,7 +391,8 @@
Container reference(cont);
Container test_cont(cont);
- range_return_t range_result = test_range_t()(policy, test_cont);
+ test_range_t test_range_fn;
+ range_return_t range_result = test_range_fn(policy, test_cont);
iterator_t reference_it = policy.reference(reference);
check_results<result_type>::test(test_cont, reference,