Release 1.54.0

[SVN r84923]

doc/boost_range.qbk

@@ -171,7 +171,7 @@
 [def __metafunctions__          [@boost:/libs/mpl/doc/refmanual/metafunction.html metafunctions]]
 [def __concept_check__          [@boost:/libs/concept_check/index.html Boost Concept Check library]]
 [def __boost_array__            [@boost:/libs/array/index.html boost::array]]
-[def __the_forwarding_problem__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm The Forwarding Problem]]
+[def __the_forwarding_problem__ [@http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm The Forwarding Problem]]
 
 [def __sgi_inner_product__      [@http://www.sgi.com/tech/stl/inner_product.html inner_product]]
 [def __sgi_partial_sum__        [@http://www.sgi.com/tech/stl/partial_sum.html partial_sum]]

include/boost/range.hpp

@@ -11,13 +11,23 @@
 #ifndef BOOST_RANGE_HPP_27_07_04
 #define BOOST_RANGE_HPP_27_07_04
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif
 
+#if _MSC_VER == 1300 // experiment
+
+#include <boost/range/detail/collection_traits.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/sub_range.hpp>
+
+#else
+
 #include <boost/range/functions.hpp>
 #include <boost/range/metafunctions.hpp>
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/sub_range.hpp>
 
+#endif // _MSC_VER == 1300 // experiment
+
 #endif

include/boost/range/adaptor/tokenized.hpp

@@ -52,9 +52,9 @@ namespace boost
         template< class T, class U, class V >
         struct regex_holder
         {
-            T  re;
-            U  sub;
-            V  f;
+            const T&  re;
+            const U&  sub;
+            V         f;
 
             regex_holder( const T& rex, const U& subm, V flag ) :
                 re(rex), sub(subm), f(flag)

include/boost/range/algorithm.hpp

@@ -19,7 +19,7 @@
 // were originally written by Vladimir Prus'
 // <ghost@cs.msu.su> code from Boost Wiki
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && _MSC_VER >= 1000
 #pragma once
 #endif
 

include/boost/range/algorithm/unique.hpp

@@ -89,11 +89,11 @@ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::ty
 unique( ForwardRange& rng, BinaryPredicate pred )
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-    return ::boost::range::unique<return_begin_found>(rng, pred);
+    return ::boost::range::unique<return_begin_found>(rng);
 }
 /// \overload
 template< class ForwardRange, class BinaryPredicate >
-inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange, return_begin_found>::type
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
 unique( const ForwardRange& rng, BinaryPredicate pred )
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));

include/boost/range/as_array.hpp

@@ -11,7 +11,7 @@
 #ifndef BOOST_RANGE_AS_ARRAY_HPP
 #define BOOST_RANGE_AS_ARRAY_HPP
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif
 

include/boost/range/as_literal.hpp

@@ -11,7 +11,7 @@
 #ifndef BOOST_RANGE_AS_LITERAL_HPP
 #define BOOST_RANGE_AS_LITERAL_HPP
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif
 

include/boost/range/atl.hpp

@@ -35,6 +35,15 @@
 #endif
 
 
+#if !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLESTRING)
+    #if (_MSC_VER < 1310)   // from <boost/regex/mfc.hpp>, but dubious
+        #define BOOST_RANGE_ATL_HAS_OLD_CSIMPLESTRING
+    #endif
+#endif
+
+
+
+
 // forward declarations
 //
 

include/boost/range/begin.hpp

@@ -11,7 +11,7 @@
 #ifndef BOOST_RANGE_BEGIN_HPP
 #define BOOST_RANGE_BEGIN_HPP
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif
 
@@ -26,7 +26,9 @@
 namespace boost
 {
 
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
+    !BOOST_WORKAROUND(__GNUC__, < 3) \
+    /**/
 namespace range_detail
 {
 #endif
@@ -83,7 +85,9 @@ namespace range_detail
     }
 
 
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
+    !BOOST_WORKAROUND(__GNUC__, < 3) \
+    /**/
 } // namespace 'range_detail'
 #endif
 
@@ -96,7 +100,9 @@ namespace range_adl_barrier
 template< class T >
 inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type begin( T& r )
 {
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
+    !BOOST_WORKAROUND(__GNUC__, < 3) \
+    /**/
     using namespace range_detail;
 #endif
     return range_begin( r );
@@ -105,7 +111,9 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type begin( T& r )
 template< class T >
 inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type begin( const T& r )
 {
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
+    !BOOST_WORKAROUND(__GNUC__, < 3) \
+    /**/
     using namespace range_detail;
 #endif
     return range_begin( r );

include/boost/range/category.hpp

@@ -11,7 +11,7 @@
 #ifndef BOOST_RANGE_CATEGORY_HPP
 #define BOOST_RANGE_CATEGORY_HPP
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif
 

include/boost/range/config.hpp

@@ -13,7 +13,7 @@
 
 #include <boost/detail/workaround.hpp>
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif
 
@@ -26,14 +26,18 @@
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 # define BOOST_RANGE_DEDUCED_TYPENAME typename
 #else
-#define BOOST_RANGE_DEDUCED_TYPENAME BOOST_DEDUCED_TYPENAME
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300) && !defined(_MSC_EXTENSIONS)
+#  define BOOST_RANGE_DEDUCED_TYPENAME typename
+# else
+#  define BOOST_RANGE_DEDUCED_TYPENAME BOOST_DEDUCED_TYPENAME
+# endif
 #endif
 
 #ifdef BOOST_RANGE_NO_ARRAY_SUPPORT
 #error "macro already defined!"
 #endif
 
-#if BOOST_WORKAROUND( __MWERKS__, <= 0x3003 )
+#if BOOST_WORKAROUND( BOOST_MSVC, < 1300 ) || BOOST_WORKAROUND( __MWERKS__, <= 0x3003 )
 #define BOOST_RANGE_NO_ARRAY_SUPPORT 1
 #endif
 
@@ -44,12 +48,6 @@
 #define BOOST_RANGE_ARRAY_REF() (&boost_range_array)
 #endif
 
-#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)))
-#  define BOOST_RANGE_UNUSED __attribute__((unused))
-#else
-#  define BOOST_RANGE_UNUSED
-#endif
-
 
 
 #endif

include/boost/range/const_iterator.hpp

@@ -11,12 +11,15 @@
 #ifndef BOOST_RANGE_CONST_ITERATOR_HPP
 #define BOOST_RANGE_CONST_ITERATOR_HPP
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif
 
 #include <boost/range/config.hpp>
 
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#include <boost/range/detail/const_iterator.hpp>
+#else
 
 #include <boost/range/detail/extract_optional_type.hpp>
 #include <boost/type_traits/remove_const.hpp>
@@ -59,5 +62,6 @@ namespace boost
 
 } // namespace boost
 
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 #endif

include/boost/range/const_reverse_iterator.hpp

@@ -11,7 +11,7 @@
 #ifndef BOOST_RANGE_CONST_REVERSE_ITERATOR_HPP
 #define BOOST_RANGE_CONST_REVERSE_ITERATOR_HPP
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif
 

include/boost/range/detail/as_literal.hpp

@@ -11,7 +11,7 @@
 #ifndef BOOST_RANGE_DETAIL_AS_LITERAL_HPP
 #define BOOST_RANGE_DETAIL_AS_LITERAL_HPP
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif
 

include/boost/range/detail/begin.hpp

@@ -15,6 +15,9 @@
 #include <boost/detail/workaround.hpp>
 #include <boost/range/iterator.hpp>
 #include <boost/range/detail/common.hpp>
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1310)
+# include <boost/range/value_type.hpp>
+#endif
 
 namespace boost
 {
@@ -59,11 +62,19 @@ namespace boost
         template<>
         struct range_begin<array_>
         {
+        #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)
+            template< typename T, std::size_t sz >
+            static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+            {
+                return boost_range_array;
+            }
+        #else
             template<typename T>
             static BOOST_RANGE_DEDUCED_TYPENAME range_value<T>::type* fun(T& t)
             {
                 return t;
             }
+        #endif
         };
 
     } // namespace 'range_detail'

include/boost/range/detail/collection_traits_detail.hpp

@@ -185,6 +185,7 @@ namespace boost {
 
 // Array container traits ---------------------------------------------------------------
 
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
             // array traits ( partial specialization )
             template< typename T >
             struct array_traits;
@@ -203,6 +204,125 @@ namespace boost {
                 BOOST_STATIC_CONSTANT( size_type, array_size = sz );
             };
 
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+            // array traits ( no partial specialization )
+            /*
+                without partial specialization we are able to
+                provide support only for a limited number of
+                types. Currently the primitive numeric types 
+                are supported
+            */
+            template< typename T, typename BaseT >
+            struct array_traits_impl
+            {
+                typedef BaseT value_type;
+                typedef BaseT* iterator;
+                typedef const BaseT* const_iterator;
+                typedef std::size_t size_type;
+                typedef std::ptrdiff_t difference_type;
+
+                // size of the array
+                BOOST_STATIC_CONSTANT( size_type, array_size = sizeof(T)/sizeof(BaseT) );
+            };
+            
+            template< typename T, typename BaseT >
+            struct array_traits_impl_selector
+            {
+                typedef array_traits_impl<T,BaseT> type;
+            };
+
+            struct array_traits_void
+            {
+                typedef void type;
+            };
+
+            template< typename T, typename BaseT >
+            struct array_traits_cv_selector
+            {
+                typedef BOOST_STRING_TYPENAME 
+                    ::boost::mpl::eval_if< 
+                        ::boost::is_convertible<T,BaseT*>,
+                        array_traits_impl_selector<T,BaseT>,
+                        ::boost::mpl::eval_if< 
+                            ::boost::is_convertible<T,const BaseT*>,
+                                array_traits_impl_selector<T, const BaseT>,
+                                ::boost::mpl::eval_if< 
+                                    ::boost::is_convertible<T, volatile BaseT*>,
+                                    array_traits_impl_selector<T, volatile BaseT>,
+                                    array_traits_impl_selector<T, const volatile BaseT>
+                                >
+                            >
+                    >::type type;
+            };
+
+            template< typename T >
+            struct array_traits_select
+            {
+                template< typename T1, typename T2 >
+                struct apply
+                {
+                    typedef BOOST_STRING_TYPENAME
+                        ::boost::mpl::eval_if< 
+                            ::boost::is_convertible<T,const volatile T2*>,
+                            array_traits_cv_selector<T,T2>,
+                            ::boost::mpl::identity<T1> >::type type;
+                };
+            };
+
+            template< typename T >
+            struct array_traits_selector 
+            {
+            private:
+                // supported array base types
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+                typedef BOOST_STRING_TYPENAME
+                    ::boost::mpl::vector10<
+                        wchar_t,
+#else // BOOST_NO_INTRINSIC_WCHAR_T
+                typedef BOOST_STRING_TYPENAME
+                    ::boost::mpl::vector9<
+#endif // BOOST_NO_INTRINSIC_WCHAR_T
+                        char,
+                        signed char,
+                        unsigned char,
+                        signed short,
+                        unsigned short,
+                        signed int,
+                        unsigned int,
+                        signed long,
+                        unsigned long
+                >::type array_base_types;
+
+            public:
+                typedef BOOST_STRING_TYPENAME
+                    ::boost::mpl::fold<
+                        array_base_types,
+                        ::boost::algorithm::detail::array_traits_void,
+                        ::boost::algorithm::detail::array_traits_select<T> >::type type;
+            };
+
+            template< typename T >
+            struct array_traits
+            {
+                typedef BOOST_STRING_TYPENAME
+                    array_traits_selector<T>::type traits_type;
+
+                typedef BOOST_STRING_TYPENAME
+                    traits_type::value_type value_type;
+                typedef BOOST_STRING_TYPENAME
+                    traits_type::iterator iterator;
+                typedef BOOST_STRING_TYPENAME
+                    traits_type::const_iterator const_iterator;
+                typedef BOOST_STRING_TYPENAME
+                    traits_type::size_type size_type;
+                typedef BOOST_STRING_TYPENAME
+                    traits_type::difference_type difference_type;
+
+                BOOST_STATIC_CONSTANT( size_type, array_size = traits_type::array_size );
+            };
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
             
             // array length resolving
             /*

include/boost/range/detail/common.hpp

@@ -11,7 +11,7 @@
 #ifndef BOOST_RANGE_DETAIL_COMMON_HPP
 #define BOOST_RANGE_DETAIL_COMMON_HPP
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif
 

include/boost/range/detail/const_iterator.hpp

@@ -0,0 +1,71 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2003-2004. 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_DETAIL_CONST_ITERATOR_HPP
+#define BOOST_RANGE_DETAIL_CONST_ITERATOR_HPP
+
+#include <boost/range/detail/common.hpp>
+#include <boost/range/detail/remove_extent.hpp>
+
+//////////////////////////////////////////////////////////////////////////////
+// missing partial specialization  workaround.
+//////////////////////////////////////////////////////////////////////////////
+
+namespace boost 
+{
+    namespace range_detail 
+    {      
+        template< typename T >
+        struct range_const_iterator_;
+
+        template<>
+        struct range_const_iterator_<std_container_>
+        {
+            template< typename C >
+            struct pts
+            {
+                typedef BOOST_RANGE_DEDUCED_TYPENAME C::const_iterator type;
+            };
+        };
+
+        template<>
+        struct range_const_iterator_<std_pair_>
+        {
+            template< typename P >
+            struct pts
+            {
+                typedef BOOST_RANGE_DEDUCED_TYPENAME P::first_type type;
+            };
+        };
+
+
+        template<>
+        struct range_const_iterator_<array_>
+        { 
+            template< typename T >
+            struct pts
+            {
+                typedef const BOOST_RANGE_DEDUCED_TYPENAME 
+                    remove_extent<T>::type* type;
+            };
+        };
+    } 
+    
+    template< typename C >
+    class range_const_iterator
+    {
+        typedef BOOST_DEDUCED_TYPENAME range_detail::range<C>::type c_type;
+    public:
+        typedef BOOST_DEDUCED_TYPENAME range_detail::range_const_iterator_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type; 
+    };
+
+}
+
+#endif

include/boost/range/detail/end.hpp

@@ -14,9 +14,15 @@
 #include <boost/config.hpp> // BOOST_MSVC
 #include <boost/detail/workaround.hpp>
 
-#include <boost/range/detail/implementation_help.hpp>
-#include <boost/range/iterator.hpp>
-#include <boost/range/detail/common.hpp>
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# include <boost/range/detail/vc6/end.hpp>
+#else
+# include <boost/range/detail/implementation_help.hpp>
+# include <boost/range/iterator.hpp>
+# include <boost/range/detail/common.hpp>
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1310)
+#  include <boost/range/detail/remove_extent.hpp>
+# endif
 
 namespace boost
 {
@@ -62,11 +68,19 @@ namespace boost
         template<>
         struct range_end<array_>
         {
+        #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)
+            template< typename T, std::size_t sz >
+            static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+            {
+                return boost::range_detail::array_end( boost_range_array );
+            }
+        #else
             template<typename T>
             static BOOST_RANGE_DEDUCED_TYPENAME remove_extent<T>::type* fun(T& t)
             {
                 return t + remove_extent<T>::size;
             }
+        #endif
         };
 
     } // namespace 'range_detail'
@@ -83,4 +97,5 @@ namespace boost
 
 } // namespace 'boost'
 
+# endif // VC6
 #endif

include/boost/range/detail/extract_optional_type.hpp

@@ -10,7 +10,7 @@
 #ifndef BOOST_RANGE_DETAIL_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED
 #define BOOST_RANGE_DETAIL_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif
 

include/boost/range/detail/implementation_help.hpp

@@ -21,13 +21,13 @@
 #include <wchar.h>
 #endif
 
-namespace boost 
+namespace boost
 {
     namespace range_detail
     {
         template <typename T>
         inline void boost_range_silence_warning( const T& ) { }
-        
+
         /////////////////////////////////////////////////////////////////////
         // end() help
         /////////////////////////////////////////////////////////////////////
@@ -36,7 +36,7 @@ namespace boost
         {
             return s + strlen( s );
         }
-        
+
 #ifndef BOOST_NO_CWCHAR
         inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
         {
@@ -51,7 +51,7 @@ namespace boost
                 ;
             return s;
         }
-#endif         
+#endif
 
         template< class Char >
         inline Char* str_end( Char* s )
@@ -64,7 +64,7 @@ namespace boost
         {
             return boost_range_array + sz;
         }
-        
+
         template< class T, std::size_t sz >
         inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz] )
         {
@@ -74,7 +74,7 @@ namespace boost
         /////////////////////////////////////////////////////////////////////
         // size() help
         /////////////////////////////////////////////////////////////////////
-        
+
         template< class Char >
         inline std::size_t str_size( const Char* const& s )
         {
@@ -96,7 +96,7 @@ namespace boost
         }
 
     } // namespace 'range_detail'
-    
+
 } // namespace 'boost'
 
 

include/boost/range/detail/iterator.hpp

@@ -0,0 +1,78 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2003-2004. 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_DETAIL_ITERATOR_HPP
+#define BOOST_RANGE_DETAIL_ITERATOR_HPP
+
+#include <boost/range/detail/common.hpp>
+#include <boost/range/detail/remove_extent.hpp>
+
+#include <boost/static_assert.hpp>
+
+//////////////////////////////////////////////////////////////////////////////
+// missing partial specialization  workaround.
+//////////////////////////////////////////////////////////////////////////////
+
+namespace boost 
+{
+    namespace range_detail 
+    {        
+        template< typename T >
+        struct range_iterator_ {
+            template< typename C >
+            struct pts
+            {
+                typedef int type;
+            };
+        };
+
+        template<>
+        struct range_iterator_<std_container_>
+        {
+            template< typename C >
+            struct pts
+            {
+                typedef BOOST_RANGE_DEDUCED_TYPENAME C::iterator type;
+            };
+        };
+
+        template<>
+        struct range_iterator_<std_pair_>
+        {
+            template< typename P >
+            struct pts
+            {
+                typedef BOOST_RANGE_DEDUCED_TYPENAME P::first_type type;
+            };
+        };
+
+        template<>
+        struct range_iterator_<array_>
+        { 
+            template< typename T >
+            struct pts
+            {
+                typedef BOOST_RANGE_DEDUCED_TYPENAME 
+                    remove_extent<T>::type* type;
+            };
+        };
+        
+    } 
+
+    template< typename C >
+    class range_mutable_iterator
+    {
+        typedef BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type c_type;
+    public:
+        typedef typename range_detail::range_iterator_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type; 
+    };
+}
+
+#endif

include/boost/range/detail/join_iterator.hpp

@@ -23,10 +23,6 @@
 #include <boost/range/empty.hpp>
 #include <boost/range/detail/demote_iterator_traversal_tag.hpp>
 #include <boost/range/value_type.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_reference.hpp>
 #include <boost/next_prior.hpp>
 
 namespace boost
@@ -75,9 +71,7 @@ public:
 
     Reference dereference(unsigned int selected) const
     {
-        if (selected)
-            return *m_it2;
-        return *m_it1;
+        return selected ? *m_it2 : *m_it1;
     }
 
     bool equal(const join_iterator_union& other, unsigned int selected) const
@@ -150,7 +144,7 @@ template<typename Iterator1
                                 >::type
                             >::value,
                             typename add_const<
-                                typename iterator_reference<Iterator1>::type
+                                typename iterator_reference<Iterator2>::type
                             >::type,
                             typename iterator_reference<Iterator1>::type
                         >::type

include/boost/range/detail/range_return.hpp

@@ -168,7 +168,7 @@ namespace boost
         typedef boost::iterator_range<
             BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type > type;
 
-        static type pack(BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type,
+        static type pack(BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type found,
                          SinglePassRange& rng)
         {
             return type(boost::begin(rng), boost::end(rng));

include/boost/range/detail/size.hpp

@@ -0,0 +1,159 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2003-2004. 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_DETAIL_SIZE_HPP
+#define BOOST_RANGE_DETAIL_SIZE_HPP
+
+#include <boost/config.hpp> // BOOST_MSVC
+#include <boost/detail/workaround.hpp>
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# include <boost/range/detail/vc6/size.hpp>
+#else
+# include <boost/range/detail/implementation_help.hpp>
+# include <boost/range/detail/size_type.hpp>
+# include <boost/range/detail/common.hpp>
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+#  include <boost/range/detail/remove_extent.hpp>
+# endif
+# include <iterator>
+
+namespace boost 
+{
+    namespace range_detail
+    {
+        template< typename T >
+        struct range_size_;
+
+        //////////////////////////////////////////////////////////////////////
+        // default
+        //////////////////////////////////////////////////////////////////////
+        
+        template<>
+        struct range_size_<std_container_>
+        {
+            template< typename C >
+            static BOOST_RANGE_DEDUCED_TYPENAME C::size_type fun( const C& c )
+            {
+                return c.size();
+            };
+        };
+                    
+        //////////////////////////////////////////////////////////////////////
+        // pair
+        //////////////////////////////////////////////////////////////////////
+        
+        template<>
+        struct range_size_<std_pair_>
+        {
+            template< typename P >
+            static BOOST_RANGE_DEDUCED_TYPENAME range_size<P>::type 
+            fun( const P& p )
+            {
+                return std::distance( p.first, p.second );
+            }
+        };
+ 
+        //////////////////////////////////////////////////////////////////////
+        // array
+        //////////////////////////////////////////////////////////////////////
+        
+        template<>
+        struct range_size_<array_>
+        {
+        #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+            template< typename T, std::size_t sz >
+            static std::size_t fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+            {
+                return sz;
+            }
+        #else
+            template<typename T>
+            static std::size_t fun(T& t)
+            {
+                return remove_extent<T>::size;
+            }
+        #endif
+        };
+        
+        template<>
+        struct range_size_<char_array_>
+        {
+            template< typename T, std::size_t sz >
+            static std::size_t fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+            {
+                return boost::range_detail::array_size( boost_range_array );
+            }
+        };
+        
+        template<>
+        struct range_size_<wchar_t_array_>
+        {
+            template< typename T, std::size_t sz >
+            static std::size_t fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+            {
+                return boost::range_detail::array_size( boost_range_array );
+            }
+        };
+
+        //////////////////////////////////////////////////////////////////////
+        // string
+        //////////////////////////////////////////////////////////////////////
+
+        template<>
+        struct range_size_<char_ptr_>
+        {
+            static std::size_t fun( const char* s )
+            {
+                return boost::range_detail::str_size( s );
+            }
+        };
+
+        template<>
+        struct range_size_<const_char_ptr_>
+        {
+            static std::size_t fun( const char* s )
+            {
+                return boost::range_detail::str_size( s );
+            }
+        };
+        
+        template<>
+        struct range_size_<wchar_t_ptr_>
+        {
+            static std::size_t fun( const wchar_t* s )
+            {
+                return boost::range_detail::str_size( s );
+            }
+        };
+
+        template<>
+        struct range_size_<const_wchar_t_ptr_>
+        {
+            static std::size_t fun( const wchar_t* s )
+            {
+                return boost::range_detail::str_size( s );
+            }
+        };
+  
+    } // namespace 'range_detail'
+    
+
+    template< typename C >
+    BOOST_RANGE_DEDUCED_TYPENAME range_size<C>::type 
+    size( const C& c )
+    {
+        return range_detail::range_size_<  BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type >::fun( c );
+    }
+    
+} // namespace 'boost'
+
+# endif
+#endif

include/boost/range/detail/sizer.hpp

@@ -11,7 +11,7 @@
 #ifndef BOOST_RANGE_DETAIL_SIZER_HPP
 #define BOOST_RANGE_DETAIL_SIZER_HPP
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif