Release 1.51.0

[SVN r80098]

doc/reference/adaptors/examples/adjacent_filtered.cpp

@@ -11,7 +11,7 @@
 #include <boost/range/algorithm/copy.hpp>
 #include <boost/assign.hpp>
 #include <algorithm>
-#include <functinoal>
+#include <functional>
 #include <iostream>
 #include <vector>
 

doc/reference/adaptors/examples/indexed.cpp

@@ -41,5 +41,5 @@ int main(int argc, const char* argv[])
     display_element_and_index( input | indexed(0) );
     
     return 0;
-]
+}
 

doc/reference/adaptors/examples/transformed.cpp

@@ -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>

doc/reference/semantics.qbk

@@ -128,7 +128,7 @@
     ]
     [
         [`size(x)`]
-        [`range_difference<X>::type`]
+        [`range_size<X>::type`]
         [`range_calculate_size(x)` which by default is `boost::end(x) - boost::begin(x)`. Users may supply alternative implementations by implementing `range_calculate_size(x)` so that it will be found via ADL]
         [constant time]
     ]

doc/upgrade.qbk

@@ -5,6 +5,12 @@
 /]
 [section:upgrade Upgrade version of Boost.Range]
 
+[section:upgrade_from_1_49 Upgrade from version 1.49]
+
+# __size__ now returns the type Rng::size_type if the range has size_type;
+otherwise range_size<Rng>::type is used. This is the distance type promoted to
+an unsigned type.
+
 [section:upgrade_from_1_45 Upgrade from version 1.45]
 
 # __size__ in addition to supporting __random_access_range__ now also supports extensibility via calls to the unqualified `range_calculate_size(rng)` function.

include/boost/range.hpp

@@ -15,7 +15,7 @@
 # pragma once
 #endif
 
-#if defined(_MSC_VER) && (_MSC_VER == 1300)
+#if _MSC_VER == 1300 // experiment
 
 #include <boost/range/detail/collection_traits.hpp>
 #include <boost/range/iterator_range.hpp>
@@ -28,6 +28,6 @@
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/sub_range.hpp>
 
-#endif // _MSC_VER == 1300
+#endif // _MSC_VER == 1300 // experiment
 
 #endif

include/boost/range/adaptor/adjacent_filtered.hpp

@@ -143,10 +143,6 @@ namespace boost
                          skip_iter(boost::end(r), boost::end(r), p))
             {
             }
-
-        private:
-            P m_pred;
-            R* m_range;
         };
 
         template< class T >

include/boost/range/adaptor/define_adaptor.hpp

@@ -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 \
     { \

include/boost/range/adaptor/strided.hpp

@@ -176,6 +176,7 @@ namespace boost
             strided_iterator()
                 : m_first()
                 , m_last()
+                , m_index(0)
                 , m_stride()
             {
             }
@@ -184,6 +185,7 @@ namespace boost
                 : super_t(it)
                 , m_first(first)
                 , m_last(last)
+                , m_index(stride ? (it - first) / stride : 0)
                 , m_stride(stride)
             {
             }
@@ -194,6 +196,7 @@ namespace boost
                 : 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 @@ namespace boost
             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();
+                m_index += m_stride;
-                if ((m_last - it) > m_stride)
+                if (m_index < (m_last - m_first))
-                    it += m_stride;
+                    this->base_reference() = m_first + m_index;
                 else
-                    it = m_last;
+                    this->base_reference() = m_last;
             }
 
             void decrement()
             {
-                base_iterator& it = this->base_reference();
+                m_index -= m_stride;
-                if ((it - m_first) > m_stride)
+                if (m_index >= 0)
-                    it -= m_stride;
+                    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)
+                m_index += offset;
-                {
+                if (m_index < 0)
-                    if ((m_last - it) > offset)
+                    this->base_reference() = m_first;
-                        it += offset;
+                else if (m_index > (m_last - m_first))
+                    this->base_reference() = m_last;
                 else
-                        it = m_last;
+                    this->base_reference() = m_first + m_index;
-                }
-                else
-                {
-                    if ((m_first - it) > offset)
-                        it += offset;
-                    else
-                        it = m_first;
-                }
             }
 
             template<class OtherIterator>
@@ -252,12 +248,13 @@ namespace boost
 
             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;
         };
 

include/boost/range/adaptor/transformed.hpp

@@ -42,8 +42,8 @@ namespace boost
             typedef R source_range_type;
 
             transformed_range( F f, R& r )
-                : base( make_transform_iterator( boost::begin(r), f ),
+                : base( boost::make_transform_iterator( boost::begin(r), f ),
-                        make_transform_iterator( boost::end(r), f ) )
+                        boost::make_transform_iterator( boost::end(r), f ) )
 
             { }
         };

include/boost/range/algorithm/equal.hpp

@@ -31,7 +31,7 @@ namespace boost
                                 IteratorCategoryTag1,
                                 IteratorCategoryTag2 )
         {
-            do
+            while (true)
             {
                 // If we have reached the end of the left range then this is
                 // the end of the loop. They are equal if and only if we have
@@ -46,7 +46,12 @@ namespace boost
                     return false;
 
                 // continue looping if and only if the values are equal
-            } while(*first1++ == *first2++);
+                if (*first1 != *first2)
+                    break;
+
+                ++first1;
+                ++first2;
+            }
 
             // Reaching this line in the algorithm indicates that a value
             // inequality has been detected.
@@ -66,7 +71,7 @@ namespace boost
                                 IteratorCategoryTag1,
                                 IteratorCategoryTag2 )
         {
-            do
+            while (true)
             {
                 // If we have reached the end of the left range then this is
                 // the end of the loop. They are equal if and only if we have
@@ -81,7 +86,12 @@ namespace boost
                     return false;
 
                 // continue looping if and only if the values are equal
-            } while(pred(*first1++, *first2++));
+                if (!pred(*first1, *first2))
+                    break;
+
+                ++first1;
+                ++first2;
+            }
 
             // Reaching this line in the algorithm indicates that a value
             // inequality has been detected.
@@ -182,7 +192,7 @@ namespace boost
         }
 
     } // namespace range
-    using range::equal;
+    using ::boost::range::equal;
 } // namespace boost
 
 #endif // include guard

include/boost/range/algorithm/for_each.hpp

@@ -13,13 +13,52 @@
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/concepts.hpp>
+#include <boost/ref.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 +69,18 @@ template< class SinglePassRange, class UnaryFunction >
 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 +88,18 @@ template< class SinglePassRange, class UnaryFunction >
 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

include/boost/range/algorithm_ext/copy_n.hpp

@@ -30,15 +30,15 @@ namespace boost
 ///
 /// \pre SinglePassRange is a model of the SinglePassRangeConcept
 /// \pre OutputIterator is a model of the OutputIteratorConcept
-/// \pre 0 <= n < distance(rng)
+/// \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>(::boost::distance(rng)) );
     BOOST_ASSERT( n >= static_cast<Size>(0) );
 
-    BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type source = boost::begin(rng);
+    BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type source = ::boost::begin(rng);
 
     for (Size i = 0; i < n; ++i, ++out, ++source)
         *out = *source;
@@ -47,7 +47,7 @@ inline OutputIterator copy_n(const SinglePassRange& rng, Size n, OutputIterator
 }
 
     } // namespace range
-    using range::copy_n;
+    using ::boost::range::copy_n;
 } // namespace boost
 
 #endif // include guard

include/boost/range/any_range.hpp

@@ -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>

include/boost/range/as_literal.hpp

@@ -74,7 +74,7 @@ namespace boost
 #endif
 
         template< class T >
-        inline long is_char_ptr( T /* r */ )
+        inline long is_char_ptr( const T& /* r */ )
         {
             return 0L;
         }

include/boost/range/counting_range.hpp

@@ -18,7 +18,6 @@
 #include <boost/range/iterator_range_core.hpp>
 #include <boost/range/value_type.hpp>
 #include <boost/iterator/counting_iterator.hpp>
-#include <boost/utility.hpp>
 
 namespace boost
 {

include/boost/range/detail/any_iterator.hpp

@@ -11,7 +11,6 @@
 #define BOOST_RANGE_DETAIL_ANY_ITERATOR_HPP_INCLUDED
 
 #include <boost/cast.hpp>
-#include <boost/utility.hpp>
 #include <boost/mpl/and.hpp>
 #include <boost/mpl/or.hpp>
 #include <boost/mpl/not.hpp>

include/boost/range/detail/any_iterator_buffer.hpp

@@ -13,7 +13,7 @@
 #include <boost/array.hpp>
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
-#include <boost/utility.hpp>
+#include <boost/noncopyable.hpp>
 
 namespace boost
 {

include/boost/range/detail/demote_iterator_traversal_tag.hpp

@@ -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 @@ namespace boost
     {
 
 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 @@ BOOST_DEMOTE_TRAVERSAL_TAG( random_access_traversal_tag, random_access_traversal
 
 #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
 

include/boost/range/detail/detail_str.hpp

@@ -134,8 +134,8 @@ namespace boost
 
 #include <boost/range/detail/begin.hpp>
 #include <boost/range/detail/end.hpp>
-#include <boost/range/detail/size_type>
+#include <boost/range/detail/size_type.hpp>
-#include <boost/range/detail/value_type>
+#include <boost/range/detail/value_type.hpp>
 #include <boost/range/detail/common.hpp>
 
 namespace boost