This commit was manufactured by cvs2svn to create tag

'Version_1_33_1'. [SVN r31916]
More cleanups
2026-02-07 07:34:35 +01:00 · 2005-12-05 14:04:06 +00:00 · 2005-12-01 15:00:34 +00:00 · 2005-11-23 16:03:02 +00:00
10 changed files with 264 additions and 264 deletions
--- a/doc/example.cpp
+++ b/doc/example.cpp
@@ -3,106 +3,106 @@

 namespace Foo
 {
-	//
-	// Our sample UDT. A 'Pair'
-	// will work as a range when the stored
-	// elements are iterators.
-	//
-	template< class T >
-	struct Pair
-	{
-		T first, last;	
-	};
+        //
+        // Our sample UDT. A 'Pair'
+        // will work as a range when the stored
+        // elements are iterators.
+        //
+        template< class T >
+        struct Pair
+        {
+                T first, last;
+        };

 } // namespace 'Foo'

 namespace boost
 {
-	//
-	// Specialize metafunctions. We must include the range.hpp header.
-	// We must open the 'boost' namespace.
-	//
-	/*
-	template< class T >
-	struct range_value< Foo::Pair<T> >
-	{
-		typedef typename std::iterator_traits<T>::value_type type;
-	};
-	*/
+        //
+        // Specialize metafunctions. We must include the range.hpp header.
+        // We must open the 'boost' namespace.
+        //
+        /*
+        template< class T >
+        struct range_value< Foo::Pair<T> >
+        {
+                typedef typename std::iterator_traits<T>::value_type type;
+        };
+        */

-	template< class T >
-	struct range_iterator< Foo::Pair<T> >
-	{
-		typedef T type;
-	};
+        template< class T >
+        struct range_iterator< Foo::Pair<T> >
+        {
+                typedef T type;
+        };

-	template< class T >
-	struct range_const_iterator< Foo::Pair<T> >
-	{
-		//
-		// Remark: this is defined similar to 'range_iterator'
-		//         because the 'Pair' type does not distinguish
-		//         between an iterator and a const_iterator.
-		//
-		typedef T type;
-	};
+        template< class T >
+        struct range_const_iterator< Foo::Pair<T> >
+        {
+                //
+                // Remark: this is defined similar to 'range_iterator'
+                //         because the 'Pair' type does not distinguish
+                //         between an iterator and a const_iterator.
+                //
+                typedef T type;
+        };

-	/*
+        /*
    template< class T >
-	struct range_difference< Foo::Pair<T> >
-	{
-		typedef typename std::iterator_traits<T>::difference_type type;
-	};
-	*/
+        struct range_difference< Foo::Pair<T> >
+        {
+                typedef typename std::iterator_traits<T>::difference_type type;
+        };
+        */

-	template< class T >
+        template< class T >
    struct range_size< Foo::Pair<T> >
-	{
-		int static_assertion[ sizeof( std::size_t ) >= 
-			  sizeof( typename range_difference< Foo::Pair<T> >::type ) ];
-		typedef std::size_t type;
-	};
+        {
+                int static_assertion[ sizeof( std::size_t ) >=
+                          sizeof( typename range_difference< Foo::Pair<T> >::type ) ];
+                typedef std::size_t type;
+        };

 } // namespace 'boost'

 namespace Foo
 {
-	//
-	// The required functions. These should be defined in
-	// the same namespace as 'Pair', in this case 
-	// in namespace 'Foo'.
-	//
-	
-	template< class T >
-	inline T boost_range_begin( Pair<T>& x )
-	{ 
-		return x.first;
-	}
+        //
+        // The required functions. These should be defined in
+        // the same namespace as 'Pair', in this case
+        // in namespace 'Foo'.
+        //
+
+        template< class T >
+        inline T boost_range_begin( Pair<T>& x )
+        {
+                return x.first;
+        }

    template< class T >
-	inline T boost_range_begin( const Pair<T>& x )
-	{ 
-		return x.first;
-	}
+        inline T boost_range_begin( const Pair<T>& x )
+        {
+                return x.first;
+        }

-	template< class T >
+        template< class T >
    inline T boost_range_end( Pair<T>& x )
-	{ 
-		return x.last;
-	}
+        {
+                return x.last;
+        }

-	template< class T >
+        template< class T >
    inline T boost_range_end( const Pair<T>& x )
-	{ 
-		return x.last;
-	}
+        {
+                return x.last;
+        }

-	template< class T >
-	inline typename boost::range_size< Pair<T> >::type
-	boost_range_size( const Pair<T>& x )
-	{
-		return std::distance(x.first,x.last);
-	}
+        template< class T >
+        inline typename boost::range_size< Pair<T> >::type
+        boost_range_size( const Pair<T>& x )
+        {
+                return std::distance(x.first,x.last);
+        }

 } // namespace 'Foo'

@@ -110,32 +110,32 @@ namespace Foo

 int main()
 {
-	typedef std::vector<int>::iterator  iter;
-	std::vector<int>                    vec;
-	vec.push_back( 42 );
-	Foo::Pair<iter>                     pair  = { vec.begin(), vec.end() };
-	const Foo::Pair<iter>&              cpair = pair; 
-	//
-	// Notice that we call 'begin' etc with qualification. 
-	//
-	iter i = boost::begin( pair );
-	iter e = boost::end( pair );
-	i      = boost::begin( cpair );
-	e      = boost::end( cpair );
-	boost::range_size< Foo::Pair<iter> >::type s = boost::size( pair );
-	s      = boost::size( cpair );
-	boost::range_const_reverse_iterator< Foo::Pair<iter> >::type
-	ri     = boost::rbegin( cpair ),
-	re	   = boost::rend( cpair );
-	
-	//
-	// Test metafunctions
-	//
+        typedef std::vector<int>::iterator  iter;
+        std::vector<int>                    vec;
+        vec.push_back( 42 );
+        Foo::Pair<iter>                     pair  = { vec.begin(), vec.end() };
+        const Foo::Pair<iter>&              cpair = pair;
+        //
+        // Notice that we call 'begin' etc with qualification.
+        //
+        iter i = boost::begin( pair );
+        iter e = boost::end( pair );
+        i      = boost::begin( cpair );
+        e      = boost::end( cpair );
+        boost::range_size< Foo::Pair<iter> >::type s = boost::size( pair );
+        s      = boost::size( cpair );
+        boost::range_const_reverse_iterator< Foo::Pair<iter> >::type
+        ri     = boost::rbegin( cpair ),
+        re         = boost::rend( cpair );

-	boost::range_value< Foo::Pair<iter> >::type 
-	v = *boost::begin(pair);
+        //
+        // Test metafunctions
+        //

-	boost::range_difference< Foo::Pair<iter> >::type 
-	d = boost::end(pair) - boost::begin(pair);
+        boost::range_value< Foo::Pair<iter> >::type
+        v = *boost::begin(pair);
+
+        boost::range_difference< Foo::Pair<iter> >::type
+        d = boost::end(pair) - boost::begin(pair);
 }

--- a/doc/intro.html
+++ b/doc/intro.html
@@ -87,7 +87,7 @@ free-standing functions so syntactic and/or semantic differences can be removed.
    </span><span class=special>{
       </span><span class=keyword>return </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>find</span><span class=special>( </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>c </span><span class=special>), </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>end</span><span class=special>( </span><span class=identifier>c </span><span class=special>), </span><span class=identifier>value </span><span class=special>);
    </span><span class=special>}
-    
+
    </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardReadableRange</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
    </span><span class=keyword>inline </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_const_iterator</span><span class=special>&lt; </span><span
 class=identifier>ForwardReadableRange </span><span class=special>&gt;::</span><span class=identifier>type
@@ -95,7 +95,7 @@ class=identifier>ForwardReadableRange </span><span class=special>&gt;::</span><s
    </span><span class=special>{
       </span><span class=keyword>return </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>find</span><span class=special>( </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>c </span><span class=special>), </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>end</span><span class=special>( </span><span class=identifier>c </span><span class=special>), </span><span class=identifier>value </span><span class=special>);
    </span><span class=special>}
-                   
+
    </span><span class=comment>//
    // replace first value and return its index
    //
@@ -104,7 +104,7 @@ class=identifier>ForwardReadableRange </span><span class=special>&gt;::</span><s
    </span><span class=identifier>my_generic_replace</span><span class=special>( </span><span class=identifier>ForwardReadableWriteableRange</span><span class=special>&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>value</span><span class=special>, </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>replacement </span><span class=special>)
    </span><span class=special>{
       </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_iterator</span><span class=special>&lt; </span><span class=identifier>ForwardReadableWriteableRange </span><span class=special>&gt;::</span><span class=identifier>type </span><span class=identifier>found </span><span class=special>= </span><span class=identifier>find</span><span class=special>( </span><span class=identifier>c</span><span class=special>, </span><span class=identifier>value </span><span class=special>);
-       
+
       </span><span class=keyword>if</span><span class=special>( </span><span class=identifier>found </span><span class=special>!= </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>end</span><span class=special>( </span><span class=identifier>c </span><span class=special>) </span><span class=special>)
           </span><span class=special>*</span><span class=identifier>found </span><span class=special>= </span><span class=identifier>replacement</span><span class=special>;
       </span><span class=keyword>return </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>distance</span><span class=special>( </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>c </span><span class=special>), </span><span class=identifier>found </span><span class=special>);
@@ -115,30 +115,30 @@ class=identifier>ForwardReadableRange </span><span class=special>&gt;::</span><s
    //
    </span><span class=keyword>const </span><span class=keyword>int </span><span class=identifier>N </span><span class=special>= </span><span class=number>5</span><span class=special>;
    </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>vector</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt; </span><span class=identifier>my_vector</span><span class=special>;
-    </span><span class=keyword>int </span><span class=identifier>values</span><span class=special>[] </span><span class=special>= </span><span class=special>{ </span><span class=number>1</span><span class=special>,</span><span class=number>2</span><span class=special>,</span><span class=number>3</span><span class=special>,</span><span class=number>4</span><span class=special>,</span><span class=number>5</span><span class=special>,</span><span class=number>6</span><span class=special>,</span><span class=number>7</span><span class=special>,</span><span class=number>8</span><span class=special>,</span><span class=number>9 </span><span class=special>};       
+    </span><span class=keyword>int </span><span class=identifier>values</span><span class=special>[] </span><span class=special>= </span><span class=special>{ </span><span class=number>1</span><span class=special>,</span><span class=number>2</span><span class=special>,</span><span class=number>3</span><span class=special>,</span><span class=number>4</span><span class=special>,</span><span class=number>5</span><span class=special>,</span><span class=number>6</span><span class=special>,</span><span class=number>7</span><span class=special>,</span><span class=number>8</span><span class=special>,</span><span class=number>9 </span><span class=special>};
    </span>
-    <span class=identifier>my_vector</span><span class=special>.</span><span 
+    <span class=identifier>my_vector</span><span class=special>.</span><span
 class=identifier>assign</span><span class=special>( </span><span class=identifier>values</span><span class=special>, </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>end</span><span class=special>( </span><span class=identifier>values </span><span class=special>) </span><span class=special>);</span>
    </span><span class=keyword>typedef </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>vector</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;::</span><span class=identifier>iterator </span><span class=identifier>iterator</span><span class=special>;
    </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special>&lt;</span><span class=identifier>iterator</span><span class=special>,</span><span class=identifier>iterator</span><span class=special>&gt;       </span><span class=identifier>my_view</span><span class=special>( </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>my_vector </span><span class=special>),
                                                </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>my_vector </span><span class=special>) </span><span class=special>+ </span><span class=identifier>N </span><span class=special>);
    </span><span class=keyword>char  </span><span class=identifier>str_val</span><span class=special>[] </span><span class=special>= </span><span class=string>&quot;a string&quot;</span><span class=special>;
    </span><span class=keyword>char</span><span class=special>* </span><span class=identifier>str       </span><span class=special>= </span><span class=identifier>str_val</span><span class=special>;
-    
-    </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>cout </span><span class=special>&lt;&lt; </span><span class=identifier>my_generic_replace</span><span class=special>( </span><span class=identifier>my_vector</span><span class=special>, </span><span class=number>4</span><span class=special>, </span><span class=number>2 </span><span class=special>)
-              </span><span class=special>&lt;&lt; </span><span class=identifier>my_generic_replace</span><span class=special>( </span><span class=identifier>my_view</span><span class=special>, </span><span class=number>4</span><span class=special>, </span><span class=number>2 </span><span class=special>)
-              </span><span class=special>&lt;&lt; </span><span class=identifier>my_generic_replace</span><span class=special>( </span><span class=identifier>str</span><span class=special>, </span><span class=literal>'a'</span><span class=special>, </span><span class=literal>'b' </span><span class=special>);
+
+    </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>cout </span><span class=special>&lt;&lt; </span><span class=identifier>my_generic_replace</span><span class=special>( </span><span class=identifier>my_vector</span><span class=special>, </span><span class=number>4</span><span class=special>, </span><span class=number>2 </span><span class=special>);
+    </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>cout </span><span class=special>&lt;&lt; </span><span class=identifier>my_generic_replace</span><span class=special>( </span><span class=identifier>my_view</span><span class=special>, </span><span class=number>4</span><span class=special>, </span><span class=number>2 </span><span class=special>);
+    </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>cout </span><span class=special>&lt;&lt; </span><span class=identifier>my_generic_replace</span><span class=special>( </span><span class=identifier>str</span><span class=special>, </span><span class=literal>'a'</span><span class=special>, </span><span class=literal>'b' </span><span class=special>);
 </span>
    <span class=comment>// prints '3', '5' and '0'     </span>
    </pre>
    </blockquote>

-    By using the free-standing functions and <a 
-href="../../mpl/doc/refmanual/metafunction.html">metafunctions</a>, the code automatically 
-    works for all the types supported by this library; now and in the future. 
+    By using the free-standing functions and <a
+href="../../mpl/doc/refmanual/metafunction.html">metafunctions</a>, the code automatically
+    works for all the types supported by this library; now and in the future.
 Notice that we have to
-    provide two version of <code  >find()</code> since we cannot forward a non-const 
-    rvalue with reference arguments (see this article about  <a href="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm" target="_self" >The 
+    provide two version of <code  >find()</code> since we cannot forward a non-const
+    rvalue with reference arguments (see this article about  <a href="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm" target="_self" >The
    Forwarding Problem</a> ).

    </p>
--- a/include/boost/range/begin.hpp
+++ b/include/boost/range/begin.hpp
@@ -47,8 +47,8 @@ namespace range_detail
    }

    template< typename C >
-    inline BOOST_DEDUCED_TYPENAME range_iterator< 
-									typename remove_const<C>::type >::type
+    inline BOOST_DEDUCED_TYPENAME range_iterator<
+                                                                        typename remove_const<C>::type >::type
    boost_range_begin( C& c )
    {
        return c.begin();
@@ -142,8 +142,8 @@ namespace range_detail


 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_iterator< 
-			typename remove_const<T>::type >::type begin( T& r )
+inline BOOST_DEDUCED_TYPENAME range_iterator<
+                        typename remove_const<T>::type >::type begin( T& r )
 {
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
    !BOOST_WORKAROUND(__GNUC__, < 3) \
--- a/include/boost/range/difference_type.hpp
+++ b/include/boost/range/difference_type.hpp
@@ -21,13 +21,13 @@

 namespace boost
 {
-	template< class T >
-	struct range_difference
-	{
-		typedef BOOST_DEDUCED_TYPENAME iterator_difference<
-			BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type >::type 
-				type;
-	};
+        template< class T >
+        struct range_difference
+        {
+                typedef BOOST_DEDUCED_TYPENAME iterator_difference<
+                        BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type >::type
+                                type;
+        };
 }

 //#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
@@ -43,13 +43,13 @@ namespace boost
    //////////////////////////////////////////////////////////////////////////
    // default
    //////////////////////////////////////////////////////////////////////////
-    
+
    template< typename C >
    struct range_difference
    {
        typedef BOOST_DEDUCED_TYPENAME C::difference_type type;
    };
-    
+
    //////////////////////////////////////////////////////////////////////////
    // pair
    //////////////////////////////////////////////////////////////////////////
@@ -57,14 +57,14 @@ namespace boost
    template< typename Iterator >
    struct range_difference< std::pair<Iterator,Iterator> >
    {
-        typedef BOOST_DEDUCED_TYPENAME 
+        typedef BOOST_DEDUCED_TYPENAME
            iterator_difference<Iterator>::type type;
    };
-    
+
    template< typename Iterator >
    struct range_difference< const std::pair<Iterator,Iterator> >
    {
-        typedef BOOST_DEDUCED_TYPENAME 
+        typedef BOOST_DEDUCED_TYPENAME
            iterator_difference<Iterator>::type type;
    };

--- a/include/boost/range/end.hpp
+++ b/include/boost/range/end.hpp
@@ -26,35 +26,35 @@
 #include <boost/range/iterator.hpp>
 #include <boost/range/const_iterator.hpp>

-namespace boost 
+namespace boost
 {
-    
+
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
    !BOOST_WORKAROUND(__GNUC__, < 3) \
-    /**/ 
+    /**/
 namespace range_detail
 {
-#endif   
+#endif

        //////////////////////////////////////////////////////////////////////
        // primary template
        //////////////////////////////////////////////////////////////////////
-        
+
        template< typename C >
        inline BOOST_DEDUCED_TYPENAME range_const_iterator<C>::type
        boost_range_end( const C& c )
        {
            return c.end();
        }
-                
+
        template< typename C >
-		inline BOOST_DEDUCED_TYPENAME range_iterator< 
-					typename remove_const<C>::type >::type
+                inline BOOST_DEDUCED_TYPENAME range_iterator<
+                                        typename remove_const<C>::type >::type
        boost_range_end( C& c )
        {
            return c.end();
        }
-      
+
        //////////////////////////////////////////////////////////////////////
        // pair
        //////////////////////////////////////////////////////////////////////
@@ -64,13 +64,13 @@ namespace range_detail
        {
            return p.second;
        }
-        
+
        template< typename Iterator >
        inline Iterator boost_range_end( std::pair<Iterator,Iterator>& p )
        {
            return p.second;
        }
-        
+
        //////////////////////////////////////////////////////////////////////
        // array
        //////////////////////////////////////////////////////////////////////
@@ -78,13 +78,13 @@ namespace range_detail
        template< typename T, std::size_t sz >
        inline const T* boost_range_end( const T (&array)[sz] )
        {
-            return range_detail::array_end<T,sz>( array ); 
+            return range_detail::array_end<T,sz>( array );
        }
-        
+
        template< typename T, std::size_t sz >
        inline T* boost_range_end( T (&array)[sz] )
        {
-            return range_detail::array_end<T,sz>( array ); 
+            return range_detail::array_end<T,sz>( array );
        }

        //////////////////////////////////////////////////////////////////////
@@ -136,19 +136,19 @@ namespace range_detail

 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
    !BOOST_WORKAROUND(__GNUC__, < 3) \
-    /**/  
+    /**/
 } // namespace 'range_detail'
 #endif

 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_iterator< 
-		typename remove_const<T>::type >::type end( T& r )
+inline BOOST_DEDUCED_TYPENAME range_iterator<
+                typename remove_const<T>::type >::type end( T& r )
 {
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
    !BOOST_WORKAROUND(__GNUC__, < 3) \
    /**/
    using namespace range_detail;
-#endif        
+#endif
    return boost_range_end( r );
 }

@@ -159,7 +159,7 @@ inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type end( const T& r )
    !BOOST_WORKAROUND(__GNUC__, < 3) \
    /**/
    using namespace range_detail;
-#endif        
+#endif
    return boost_range_end( r );
 }

--- a/include/boost/range/rbegin.hpp
+++ b/include/boost/range/rbegin.hpp
@@ -26,7 +26,7 @@ namespace boost
 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type 
+inline BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type
 rbegin( C& c )
 {
    return BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type( end( c ) );
@@ -35,18 +35,18 @@ rbegin( C& c )
 #else

 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_iterator< 
-								typename remove_const<C>::type >::type 
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<
+                                                                typename remove_const<C>::type >::type
 rbegin( C& c )
 {
-    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator< 
-								typename remove_const<C>::type >::type
+    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<
+                                                                typename remove_const<C>::type >::type
        iter_type;
    return iter_type( end( c ) );
 }

 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type 
+inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
 rbegin( const C& c )
 {
    typedef BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
--- a/include/boost/range/rend.hpp
+++ b/include/boost/range/rend.hpp
@@ -22,31 +22,31 @@

 namespace boost
 {
-    
+
 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type 
+inline BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type
 rend( C& c )
 {
    return BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type( begin( c ) );
 }

 #else
-    
+
 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_iterator< 
-								typename remove_const<C>::type >::type
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<
+                                                                typename remove_const<C>::type >::type
 rend( C& c )
 {
-	typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator< 
-								typename remove_const<C>::type >::type 
+        typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<
+                                                                typename remove_const<C>::type >::type
               iter_type;
    return iter_type( begin( c ) );
 }

 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type 
+inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
 rend( const C& c )
 {
    typedef BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
--- a/include/boost/range/size_type.hpp
+++ b/include/boost/range/size_type.hpp
@@ -21,47 +21,47 @@

 namespace boost
 {
-	namespace range_detail
-	{
-		template< class T >
-		struct add_unsigned;
+        namespace range_detail
+        {
+                template< class T >
+                struct add_unsigned;

-		template<>
-		struct add_unsigned<short>
-		{
-			typedef unsigned short type;
-		};
-    
-		template<>
-		struct add_unsigned<int>
-		{
-			typedef unsigned int type;
-		};
+                template<>
+                struct add_unsigned<short>
+                {
+                        typedef unsigned short type;
+                };

-		template<>
-		struct add_unsigned<long>
-		{
-			typedef unsigned long type;
-		};
+                template<>
+                struct add_unsigned<int>
+                {
+                        typedef unsigned int type;
+                };
+
+                template<>
+                struct add_unsigned<long>
+                {
+                        typedef unsigned long type;
+                };

 #ifdef BOOST_HAS_LONG_LONG
-		
-		template<>
-		struct add_unsigned<long long>
-		{
-			typedef unsigned long long type;
-		};
+
+                template<>
+                struct add_unsigned<long long>
+                {
+                        typedef unsigned long long type;
+                };
 #endif

-	}
+        }

-	template< class T >
-	struct range_size
-	{
-		typedef BOOST_DEDUCED_TYPENAME range_detail::add_unsigned<
-					BOOST_DEDUCED_TYPENAME range_difference<T>::type >::type
-			type;
-	};
+        template< class T >
+        struct range_size
+        {
+                typedef BOOST_DEDUCED_TYPENAME range_detail::add_unsigned<
+                                        BOOST_DEDUCED_TYPENAME range_difference<T>::type >::type
+                        type;
+        };
 }
 */

@@ -77,13 +77,13 @@ namespace boost
    //////////////////////////////////////////////////////////////////////////
    // default
    //////////////////////////////////////////////////////////////////////////
-    
+
    template< typename C >
    struct range_size
    {
        typedef BOOST_DEDUCED_TYPENAME C::size_type type;
    };
-    
+
    //////////////////////////////////////////////////////////////////////////
    // pair
    //////////////////////////////////////////////////////////////////////////
@@ -93,7 +93,7 @@ namespace boost
    {
        typedef std::size_t type;
    };
-    
+
    template< typename Iterator >
    struct range_size< const std::pair<Iterator,Iterator> >
    {
--- a/include/boost/range/value_type.hpp
+++ b/include/boost/range/value_type.hpp
@@ -26,13 +26,13 @@

 namespace boost
 {
-	template< class T >
+        template< class T >
    struct range_value
-	{
-		typedef BOOST_DEDUCED_TYPENAME iterator_value< 
-			BOOST_DEDUCED_TYPENAME range_iterator<T>::type >::type
-				type;
-	};
+        {
+                typedef BOOST_DEDUCED_TYPENAME iterator_value<
+                        BOOST_DEDUCED_TYPENAME range_iterator<T>::type >::type
+                                type;
+        };
 }

 /*
@@ -45,13 +45,13 @@ namespace boost
    //////////////////////////////////////////////////////////////////////////
    // default
    //////////////////////////////////////////////////////////////////////////
-    
+
    template< typename C >
    struct range_value
    {
        typedef BOOST_DEDUCED_TYPENAME C::value_type type;
    };
-    
+
    //////////////////////////////////////////////////////////////////////////
    // pair
    //////////////////////////////////////////////////////////////////////////
@@ -59,15 +59,15 @@ namespace boost
    template< typename Iterator >
    struct range_value< std::pair<Iterator,Iterator> >
    {
-        typedef BOOST_DEDUCED_TYPENAME 
+        typedef BOOST_DEDUCED_TYPENAME
            iterator_value<Iterator>::type type;
    };
-    
-    
+
+
    template< typename Iterator >
    struct range_value< const std::pair<Iterator,Iterator> >
    {
-        typedef BOOST_DEDUCED_TYPENAME 
+        typedef BOOST_DEDUCED_TYPENAME
            iterator_value<Iterator>::type type;
    };

@@ -86,7 +86,7 @@ namespace boost
    {
        typedef const T type;
    };
-    
+
    //////////////////////////////////////////////////////////////////////////
    // string
    //////////////////////////////////////////////////////////////////////////
--- a/test/extension_mechanism.cpp
+++ b/test/extension_mechanism.cpp
@@ -27,72 +27,72 @@
 template< class Rng >
 typename boost::range_result_iterator<Rng>::type foo_algo( Rng& r )
 {
-	//
-	// This will only compile for Rng = UDT if the qualified calls
-	// find boost_range_XXX via ADL.
-	//
-	return boost::size(r) == 0u ? boost::begin(r) : boost::end(r);
+        //
+        // This will only compile for Rng = UDT if the qualified calls
+        // find boost_range_XXX via ADL.
+        //
+        return boost::size(r) == 0u ? boost::begin(r) : boost::end(r);
 }

 namespace Foo
 {
-	//
-	// Our sample UDT
-	//
-	struct X
-	{
-		typedef std::vector<int>       data_t;
-		typedef data_t::iterator       iterator;
-		typedef data_t::const_iterator const_iterator;
-		typedef data_t::size_type      size_type;
+        //
+        // Our sample UDT
+        //
+        struct X
+        {
+                typedef std::vector<int>       data_t;
+                typedef data_t::iterator       iterator;
+                typedef data_t::const_iterator const_iterator;
+                typedef data_t::size_type      size_type;

-		data_t vec;
+                data_t vec;

-		void push_back( int i )
-		{ vec.push_back(i); }
-	};
+                void push_back( int i )
+                { vec.push_back(i); }
+        };

-	//
-	// The required functions. No type-traits need
-	// to be defined because X defines the proper set of
-	// nested types. 
-	//
-	inline X::iterator boost_range_begin( X& x )
-	{ 
-		return x.vec.begin();
-	}
+        //
+        // The required functions. No type-traits need
+        // to be defined because X defines the proper set of
+        // nested types.
+        //
+        inline X::iterator boost_range_begin( X& x )
+        {
+                return x.vec.begin();
+        }
+
+
+        inline X::const_iterator boost_range_begin( const X& x )
+        {
+                return x.vec.begin();
+        }

-	
-	inline X::const_iterator boost_range_begin( const X& x )
-	{
-		return x.vec.begin();
-	}
-	

    inline X::iterator boost_range_end( X& x )
-	{ 
-		return x.vec.end();
-	}
+        {
+                return x.vec.end();
+        }

-	inline X::const_iterator boost_range_end( const X& x )
-	{
-		return x.vec.end();
-	}
+        inline X::const_iterator boost_range_end( const X& x )
+        {
+                return x.vec.end();
+        }

-	inline X::size_type boost_range_size( const X& x )
-	{
-		return x.vec.size();
-	}
+        inline X::size_type boost_range_size( const X& x )
+        {
+                return x.vec.size();
+        }
 }

 void check_extension()
 {
-	Foo::X x;
-	x.push_back(3);
-	const Foo::X x2;
+        Foo::X x;
+        x.push_back(3);
+        const Foo::X x2;

-	foo_algo( x );
-	foo_algo( x2 );
+        foo_algo( x );
+        foo_algo( x2 );
 }

 using boost::unit_test::test_suite;
Author	SHA1	Message	Date
nobody	a54b608635	This commit was manufactured by cvs2svn to create tag 'Version_1_33_1'. [SVN r31916]	2005-12-05 14:04:06 +00:00
Douglas Gregor	32847c6b64	More cleanups [SVN r31860]	2005-12-01 15:00:34 +00:00
Victor A. Wagner Jr.	bd34ecb841	Changed - output statement at end of example. cout << a << b << c; does NOT guarantee left to right evaluation. [SVN r31755]	2005-11-23 16:03:02 +00:00