Quickbook: Copy trunk headers into quickbook-dev.

[SVN r75212]

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();
-                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 @@ 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/algorithm/for_each.hpp

@@ -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 @@ 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 +89,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/irange.hpp

@@ -124,13 +124,11 @@ namespace boost
             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 @@ namespace boost
     {
         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

include/boost/range/iterator_range_core.hpp

@@ -53,13 +53,13 @@ namespace boost
             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 ) );
             }
         };
 
@@ -249,7 +249,7 @@ namespace boost
 
             difference_type size() const
             {
-				return m_End - m_Begin;
+                return m_End - m_Begin;
             }
 
             bool empty() const

include/boost/range/join.hpp

@@ -36,6 +36,9 @@ public:
 
     } // 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 @@ join(SinglePassRange1& r1, SinglePassRange2& r2)
     return joined_range<SinglePassRange1, SinglePassRange2>(r1, r2);
 }
 
+} // namespace range
+
+using ::boost::range::joined_range;
+using ::boost::range::join;
+
 } // namespace boost
 
 #endif // include guard