This commit was manufactured by cvs2svn to create tag

'Version_1_33_1_beta'. [SVN r31604]
*** empty log message ***
2005-11-08 23:18:41 +00:00 · 2005-10-31 23:11:00 +00:00 · 2005-10-31 13:29:56 +00:00 · 2005-09-14 17:05:05 +00:00 · 2005-09-12 20:08:14 +00:00 · 2005-09-09 16:11:29 +00:00
33 changed files with 410 additions and 650 deletions
--- a/doc/boost_range.html
+++ b/doc/boost_range.html
@@ -727,7 +727,7 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
 		
 		<hr>
 		<p>
-			(C) Copyright Thorsten Ottosen 2003-2004. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+			(C) Copyright Thorsten Ottosen 2003-2004
 		</p>
 		<br>
 		<br>
--- a/doc/example.cpp
+++ b/doc/example.cpp
@@ -1,115 +1,108 @@
-/*
-//  Copyright Thorsten Ottosen 2003-2005. 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)
-*/
-
 #include <boost/range.hpp>
 #include <iterator>         // for std::iterator_traits, std::distance()

 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'

@@ -117,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 );
+	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
+	//

-        //
-        // Test metafunctions
-        //
+	boost::range_value< Foo::Pair<iter> >::type 
+	v = *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);
+	boost::range_difference< Foo::Pair<iter> >::type 
+	d = boost::end(pair) - boost::begin(pair);
 }

--- a/doc/examples.html
+++ b/doc/examples.html
@@ -47,7 +47,7 @@

    <hr>
    <p>
-    (C) Copyright Thorsten Ottosen 2003-2004. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+    (C) Copyright Thorsten Ottosen 2003-2004
    </p>

    <br>
--- a/doc/faq.html
+++ b/doc/faq.html
@@ -116,7 +116,7 @@ Cool indeed!

    <hr>
    <p>
-    (C) Copyright Thorsten Ottosen 2003-2004. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+    (C) Copyright Thorsten Ottosen 2003-2004
    </p>

    <br>
--- a/doc/headers.html
+++ b/doc/headers.html
@@ -141,11 +141,6 @@
            <td  ><a href="utility_class.html#sub_range" >sub_range</a></td>
            <td>- </td>
        </tr>
-        <tr  >
-            <td  ><code  >&lt;boost/range/concepts.hpp&gt;</code></td>
-            <td  ><a href="range.html#concept_checking" >concept checks</a></td>
-            <td>- </td>
-        </tr>

    </table>
    <br
@@ -154,7 +149,7 @@

    <hr>
    <p>
-    (C) Copyright Thorsten Ottosen 2003-2004. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+    (C) Copyright Thorsten Ottosen 2003-2004
    </p>

    <br>
--- a/doc/history_ack.html
+++ b/doc/history_ack.html
@@ -56,12 +56,9 @@ C++ standard: <blockquote>
             vc6 and vc7.
    </ul>
    </p>
-    <p>
-    The concept checks and their documentation was provided by Daniel Walker.
-    
    <hr>
    <p>
-    (C) Copyright Thorsten Ottosen 2003-2006. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+    (C) Copyright Thorsten Ottosen 2003-2005
    </p>

    <br>
--- 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=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=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=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>
@@ -146,7 +146,7 @@ Notice that we have to

    <hr>
    <p>
-    (C) Copyright Thorsten Ottosen 2003-2004. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+    (C) Copyright Thorsten Ottosen 2003-2004
    </p>

    <br>
--- a/doc/portability.html
+++ b/doc/portability.html
@@ -75,7 +75,7 @@ href="http://boost.sourceforge.net/regression-logs/developer/range.html">here</a

    <hr>
    <p>
-    (C) Copyright Thorsten Ottosen 2003-2004. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+    (C) Copyright Thorsten Ottosen 2003-2004
    </p>

    <br>
--- a/doc/range.html
+++ b/doc/range.html
@@ -36,8 +36,6 @@
            <a href="#bidirectional_range">Bidirectional Range</a>
        <li>
            <a href="#random_access_range">Random Access Range</a>
-        <li>
-            <a href="#concept_checking">Concept Checking</a>
    </ul>

    <a name="overview"></a>
@@ -452,59 +450,6 @@ href="../../iterator/doc/new-iter-concepts.html#random-access-traversal-iterator

    <hr>

-    <a name=concept_checking><h2>Concept Checking</h2>
-
-    Each of the range concepts has a corresponding concept checking
-    class in the file boost/range/concepts.hpp. These classes may be
-    used in conjunction with the <a
-    href="../../concept_check/concept_check.htm">Boost Concept
-    Check</a> library to insure that the type of a template parameter
-    is compatible with a range concept. If not, a meaningful compile
-    time error is generated. Checks are provided for the range
-    concepts related to iterator traversal categories. For example,
-    the following line checks that the type <code>T</code> models the
-    <a href="#forward_range">ForwardRange</a> concept.
-
-    <pre>
-    function_requires&lt;ForwardRangeConcept&lt;T&gt; &gt;();
-    </pre>
-
-    An additional concept check is required for the value access
-    property of the range based on the range's iterator type. For
-    example to check for a ForwardReadableRange, the following code is
-    required.
-
-    <pre>
-    function_requires&lt;ForwardRangeConcept&lt;T&gt; &gt;();
-    function_requires&lt;
-        ReadableIteratorConcept&lt;
-            typename range_iterator&lt;T&gt;::type
-        &gt;
-    &gt;();
-    </pre>
-
-    The following range concept checking classes are provided.
-    <ul>
-        <li>
-            Class <code>SinglePassRangeConcept</code> checks for <a
-            href="#single_pass_range">Single Pass Range</a>
-        <li>
-            Class <code>ForwardRangeConcept</code> checks for <a
-            href="#forward_range">Forward Range</a>
-        <li>
-            Class <code>BidirectionalRangeConcept</code> checks for <a
-            href="#bidirectional_range">Bidirectional Range</a>
-        <li>
-            Class <code>RandomAccessRangeConcept</code> checks for <a
-            href="#random_access_range">Random Access Range</a>
-    </ul>
-
-    <h3>See also</h3> 
-    <p> <a href="style.html">Range Terminology and style guidelines</a></p>
-    <p> <a href="../../iterator/doc/iterator_concepts.html">Iterator Concepts</a></p>
-    <p> <a href="../../concept_check/concept_check.htm">Boost Concept Check library</a></p>
-
-    <hr>

    <!--
    <h3>Notes</h3>
@@ -530,7 +475,7 @@ href="../../iterator/doc/new-iter-concepts.html#random-access-traversal-iterator
        </TR>
        <tr >
            <TD nowrap>Copyright &copy 2004</TD>
-            <TD>Thorsten Ottosen. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+            <TD>Thorsten Ottosen.
    </TABLE>

    <br>
--- a/doc/style.css
+++ b/doc/style.css
@@ -1,10 +1,3 @@
-/*
-#//  Copyright Thorsten Ottosen 2003-2005. 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)
-*/
-
 pre{
  BORDER-RIGHT: gray 1pt solid;
  PADDING-RIGHT: 2pt;
--- a/doc/style.html
+++ b/doc/style.html
@@ -104,7 +104,7 @@

    <hr>
    <p>
-    (C) Copyright Thorsten Ottosen 2003-2004. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+    (C) Copyright Thorsten Ottosen 2003-2004
    </p>

    <br>
--- a/doc/utility_class.html
+++ b/doc/utility_class.html
@@ -352,7 +352,7 @@ store the result

 <hr>
  <p>
-    (C) Copyright Thorsten Ottosen 2003-2004. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+    (C) Copyright Thorsten Ottosen 2003-2004
  </p>

  <br>
--- 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) \
@@ -190,7 +190,7 @@ namespace boost
    inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type
    const_begin( const T& r )
    {
-        return boost::begin( r );
+        return begin( r );
    }
 }

--- a/include/boost/range/concepts.hpp
+++ b/include/boost/range/concepts.hpp
@@ -1,155 +0,0 @@
-// Boost.Range library concept checks
-//
-//  Copyright Daniel Walker 2006. Use, modification and distribution
-//  are 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_CONCEPTS_HPP
-#define BOOST_RANGE_CONCEPTS_HPP
-
-#include <boost/concept_check.hpp>
-#include <boost/iterator/iterator_concepts.hpp>
-#include <boost/range/functions.hpp>
-#include <boost/range/metafunctions.hpp>
-
-/*!
- * \file
- * \brief Concept checks for the Boost Range library.
- *
- * The structures in this file may be used in conjunction with the
- * Boost Concept Check library to insure that the type of a function
- * parameter is compatible with a range concept. If not, a meaningful
- * compile time error is generated. Checks are provided for the range
- * concepts related to iterator traversal categories. For example, the
- * following line checks that the type T models the ForwardRange
- * concept.
- *
- * \code
- * function_requires<ForwardRangeConcept<T> >();
- * \endcode
- *
- * An additional concept check is required for the value access
- * property of the range. For example to check for a
- * ForwardReadableRange, the following code is required.
- *
- * \code
- * function_requires<ForwardRangeConcept<T> >();
- * function_requires<
- *     ReadableIteratorConcept<
- *         typename range_iterator<T>::type
- *     >
- * >();
- * \endcode
- *
- * \see http://www.boost.org/libs/range/doc/range.html for details
- * about range concepts.
- * \see http://www.boost.org/libs/iterator/doc/iterator_concepts.html
- * for details about iterator concepts.
- * \see http://www.boost.org/libs/concept_check/concept_check.htm for
- * details about concept checks.
- */
-
-namespace boost {
-
-    //! Check if a type T models the SinglePassRange range concept.
-    template<typename T>
-    struct SinglePassRangeConcept {
-        typedef typename range_value<T>::type range_value;
-        typedef typename range_iterator<T>::type range_iterator;
-        typedef typename range_const_iterator<T>::type range_const_iterator;
-        void constraints()
-        {
-            function_requires<
-                boost_concepts::SinglePassIteratorConcept<
-                    range_iterator
-                >
-            >();
-            i = boost::begin(a);
-            i = boost::end(a);
-            b = boost::empty(a);
-            const_constraints(a);
-        }
-        void const_constraints(const T& a)
-        {
-            ci = boost::begin(a);
-            ci = boost::end(a);
-        }
-        T a;
-        range_iterator i;
-        range_const_iterator ci;
-        bool b;
-    };
-
-    //! Check if a type T models the ForwardRange range concept.
-    template<typename T>
-    struct ForwardRangeConcept {
-        typedef typename range_difference<T>::type range_difference;
-        typedef typename range_size<T>::type range_size;
-        void constraints()
-        {
-            function_requires<
-                SinglePassRangeConcept<T>
-            >();        
-            function_requires<
-                boost_concepts::ForwardTraversalConcept<
-                    typename range_iterator<T>::type
-                >
-            >();
-            s = boost::size(a);
-        }
-        T a;
-        range_size s;
-    };
-
-    //! Check if a type T models the BidirectionalRange range concept.
-    template<typename T>
-    struct BidirectionalRangeConcept {
-        typedef typename range_reverse_iterator<T>::type range_reverse_iterator;
-        typedef typename range_const_reverse_iterator<T>::type range_const_reverse_iterator;
-        void constraints()
-        {
-            function_requires<
-                    ForwardRangeConcept<T>
-            >();        
-            function_requires<
-                boost_concepts::BidirectionalTraversalConcept<
-                    typename range_iterator<T>::type
-                >
-            >();
-            i = boost::rbegin(a);
-            i = boost::rend(a);
-            const_constraints(a);
-            }
-        void const_constraints(const T& a)
-        {
-            ci = boost::rbegin(a);
-            ci = boost::rend(a);
-        }
-        T a;
-        range_reverse_iterator i;
-        range_const_reverse_iterator ci;
-    };
-
-    //! Check if a type T models the RandomAccessRange range concept.
-    template<typename T>
-    struct RandomAccessRangeConcept {
-        void constraints()
-        {
-            function_requires<
-                BidirectionalRangeConcept<T>
-            >();        
-            function_requires<
-                boost_concepts::RandomAccessTraversalConcept<
-                    typename range_iterator<T>::type
-                >
-            >();
-            }
-    };
-
-} // namespace boost
-
-#endif // BOOST_RANGE_CONCEPTS_HPP
--- a/include/boost/range/config.hpp
+++ b/include/boost/range/config.hpp
@@ -37,7 +37,7 @@
 #error "macro already defined!"
 #endif

-//#if BOOST_WORKAROUND( BOOST_MSVC, < 1300 ) || __MWERKS__ <= 0x3003
+//#if BOOST_WORKAROUND( BOOST_MSVC, <= 1200 ) || __MWERKS__ <= 0x3003
 #if _MSC_VER <= 1300 && !defined( __COMO__ ) && !defined( __GNUC__ ) && __MWERKS__ <= 0x3003
 #define BOOST_RANGE_NO_ARRAY_SUPPORT 1
 #endif
--- a/include/boost/range/detail/common.hpp
+++ b/include/boost/range/detail/common.hpp
@@ -78,35 +78,35 @@ namespace boost
        template< typename C >
        class range
        {
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_pair_,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::range_detail::range_helper<C>::is_pair_,
                                                                  boost::range_detail::std_pair_,
                                                                  void >::type pair_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_array_,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::range_detail::range_helper<C>::is_array_,
                                                                    boost::range_detail::array_,
                                                                    pair_t >::type array_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_string_,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::range_detail::range_helper<C>::is_string_,
                                                                    boost::range_detail::string_,
                                                                    array_t >::type string_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_char_ptr_,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::range_detail::range_helper<C>::is_const_char_ptr_,
                                                                    boost::range_detail::const_char_ptr_,
                                                                    string_t >::type const_char_ptr_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_ptr_,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::range_detail::range_helper<C>::is_char_ptr_,
                                                                    boost::range_detail::char_ptr_,
                                                                    const_char_ptr_t >::type char_ptr_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_wchar_t_ptr_,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::range_detail::range_helper<C>::is_const_wchar_t_ptr_,
                                                                    boost::range_detail::const_wchar_t_ptr_,
                                                                    char_ptr_t >::type const_wchar_ptr_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_ptr_,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::range_detail::range_helper<C>::is_wchar_t_ptr_,
                                                                    boost::range_detail::wchar_t_ptr_,
                                                                    const_wchar_ptr_t >::type wchar_ptr_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_array_,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::range_detail::range_helper<C>::is_wchar_t_array_,
                                                                    boost::range_detail::wchar_t_array_,
                                                                    wchar_ptr_t >::type wchar_array_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_array_,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::range_detail::range_helper<C>::is_char_array_,
                                                                    boost::range_detail::char_array_,
                                                                    wchar_array_t >::type char_array_t;
        public:
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::is_void<char_array_t>::value,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::is_void<char_array_t>::value,
                                                                    boost::range_detail::std_container_,
                                                                    char_array_t >::type type;  
        }; // class 'range' 
--- a/include/boost/range/detail/implementation_help.hpp
+++ b/include/boost/range/detail/implementation_help.hpp
@@ -43,7 +43,7 @@ namespace boost
 #else
        inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
        {
-            if( s == 0 || s[0] == 0 )
+            if( s == 0 && s[0] == 0 )
                return s;
            while( *++s != 0 )
                ;
@@ -54,7 +54,7 @@ namespace boost
        template< class Char >
        inline Char* str_end( Char* s )
        {
-            return const_cast<Char*>( str_end( s, s ) );
+            return (Char*)str_end( s, s );
        }

        template< class T, std::size_t sz >
--- 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 );
 }

@@ -194,7 +194,7 @@ namespace boost
    inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type
    const_end( const T& r )
    {
-        return boost::end( r );
+        return end( r );
    }
 }

--- a/include/boost/range/iterator_range.hpp
+++ b/include/boost/range/iterator_range.hpp
@@ -57,13 +57,15 @@ namespace boost
            template< class ForwardRange >
            static IteratorT adl_begin( ForwardRange& r )
            {
-                return IteratorT( boost::begin( r ) );
+                using boost::begin;
+                return IteratorT( begin( r ) );
            }
            
            template< class ForwardRange >
            static IteratorT adl_end( ForwardRange& r )
            {
-                return IteratorT( boost::end( r ) );
+                using boost::end;
+                return IteratorT( end( r ) );
            }
        };
 
@@ -72,23 +74,23 @@ namespace boost
        {
            typedef BOOST_DEDUCED_TYPENAME boost::range_size<Left>::type sz_type;

-            sz_type l_size = boost::size( l ),
-                    r_size = boost::size( r );
+            sz_type l_size = size( l ),
+                    r_size = size( r );

            if( l_size != r_size )
                return false;

-            return std::equal( boost::begin(l), boost::end(l), 
-                               boost::begin(r) );                
+            return std::equal( begin(l), end(l), 
+                               begin(r) );                
        }

        template< class Left, class Right >
        inline bool less_than( const Left& l, const Right& r )
        {                
-            return std::lexicographical_compare( boost::begin(l), 
-                                                 boost::end(l), 
-                                                 boost::begin(r), 
-                                                 boost::end(r) );                
+            return std::lexicographical_compare( begin(l), 
+                                                 end(l), 
+                                                 begin(r), 
+                                                 end(r) );                
        }
           
        struct range_tag { };
@@ -140,14 +142,6 @@ namespace boost

            //! This type
            typedef iterator_range<IteratorT> this_type;
-
-            //! Refence type
-            //
-            // Needed because value-type is the same for 
-            // const and non-const iterators
-            //
-            typedef BOOST_DEDUCED_TYPENAME
-                iterator_reference<IteratorT>::type reference;
            
            //! const_iterator type
            /*! 
@@ -261,12 +255,8 @@ namespace boost
            { 
                if( singular )
                    return 0;
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
-                return std::distance<IteratorT>( m_Begin, m_End );
-#else                
+                
                return std::distance( m_Begin, m_End );
-#endif                
            }
            
            bool empty() const
@@ -316,38 +306,26 @@ namespace boost
 #endif            

        public: // convenience
-           reference front() const
+           value_type& front() const
           {
               BOOST_ASSERT( !empty() );
               return *m_Begin;
           }
    
-           reference back() const
+           value_type& back() const
           {
               BOOST_ASSERT( !empty() );
               IteratorT last( m_End );
               return *--last;
           }
    
-           reference operator[]( size_type sz ) const
+           value_type& operator[]( size_type sz ) const
           {
               //BOOST_STATIC_ASSERT( is_random_access );
               BOOST_ASSERT( sz < size() );
               return m_Begin[sz];
           }
-
-           iterator_range& advance_begin( difference_type n )
-           {
-               std::advance( m_Begin, n );
-               return *this;
-           }
-           
-           iterator_range& advance_end( difference_type n )
-           {
-               std::advance( m_End, n );
-               return *this;
-           }
-           
+            
        private:
            // begin and end iterators
            IteratorT m_Begin;
@@ -382,10 +360,7 @@ namespace boost
                    std::basic_ostream<Elem, Traits>& Os,
                    const iterator_range<IteratorT>& r )
        {
-            std::copy( r.begin(), r.end(), 
-                       std::ostream_iterator< BOOST_DEDUCED_TYPENAME 
-                                            iterator_value<IteratorT>::type, 
-                                              Elem, Traits>(Os) );
+            std::copy( r.begin(), r.end(), std::ostream_iterator<Elem>(Os));
            return Os;
        }

@@ -504,7 +479,7 @@ namespace boost
        make_iterator_range( Range& r ) 
        {   
            return iterator_range< BOOST_DEDUCED_TYPENAME range_result_iterator<Range>::type >
-                ( boost::begin( r ), boost::end( r ) );
+                ( begin( r ), end( r ) );
        }
        
 #else
@@ -543,8 +518,8 @@ namespace boost
                    return make_iterator_range( r );

                BOOST_DEDUCED_TYPENAME range_result_iterator<Range>::type 
-                    new_begin = boost::begin( r ),
-                    new_end   = boost::end( r );
+                    new_begin = begin( r ),
+                    new_end   = end( r );
                std::advance( new_begin, advance_begin );
                std::advance( new_end, advance_end );
                return make_iterator_range( new_begin, new_end );
@@ -598,7 +573,7 @@ namespace boost
        template< typename SeqT, typename Range >
        inline SeqT copy_range( const Range& r )
        {
-            return SeqT( boost::begin( r ), boost::end( r ) );
+            return SeqT( begin( r ), end( r ) );
        }

 } // namespace 'boost'
--- 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,23 +35,23 @@ 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( boost::end( c ) );
+    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
        iter_type;
-    return iter_type( boost::end( c ) );
+    return iter_type( end( c ) );
 }

 #endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
@@ -60,7 +60,7 @@ template< class T >
 inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<T>::type
 const_rbegin( const T& r )
 {
-    return boost::rbegin( r );
+    return rbegin( r );
 }

 } // namespace 'boost'
--- a/include/boost/range/rend.hpp
+++ b/include/boost/range/rend.hpp
@@ -22,36 +22,36 @@

 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( boost::begin( 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( boost::begin( c ) );
+    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
        iter_type;
-    return iter_type( boost::begin( c ) );
+    return iter_type( begin( c ) );
 }

 #endif
@@ -60,7 +60,7 @@ template< class T >
 inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<T>::type
 const_rend( const T& r )
 {
-    return boost::rend( r );
+    return rend( r );
 }

 } // namespace 'boost'
--- 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<short>
+		{
+			typedef unsigned short type;
+		};
+    
+		template<>
+		struct add_unsigned<int>
+		{
+			typedef unsigned int type;
+		};

-                template<>
-                struct add_unsigned<int>
-                {
-                        typedef unsigned int type;
-                };
-
-                template<>
-                struct add_unsigned<long>
-                {
-                        typedef unsigned long 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/sub_range.hpp
+++ b/include/boost/range/sub_range.hpp
@@ -35,23 +35,25 @@ namespace boost
        typedef BOOST_DEDUCED_TYPENAME range_const_iterator<ForwardRange>::type   const_iterator;
        typedef BOOST_DEDUCED_TYPENAME range_difference<ForwardRange>::type       difference_type;
        typedef BOOST_DEDUCED_TYPENAME range_size<ForwardRange>::type             size_type;
-        typedef BOOST_DEDUCED_TYPENAME base::reference                            reference;
-        typedef BOOST_DEDUCED_TYPENAME iterator_reference<const_iterator>::type   const_reference;

    public:
        sub_range() : base() 
        { }
+/*
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))  
+        typedef sub_range<ForwardRange> this_type;
+        
+        sub_range( this_type r ) :
+        : base( r )
+        { }

-/*        
-        template< class ForwardRange2 >
-        sub_range( 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 */
-
+        this_type& operator=( this_type r )
+        {
+            base::operator=( r );
+            return *this;
+        }
+#endif
+*/
        template< class ForwardRange2 >
        sub_range( ForwardRange2& r ) : 
            
@@ -90,16 +92,6 @@ namespace boost
            base::operator=( r );
            return *this;
        }
-
-        sub_range& operator=( sub_range r )
-        {
-            //
-            // argument passed by value to avoid 
-            // const_iterator to iterator conversion
-            //
-            base::operator=( r );
-            return *this;            
-        }
        
    public:
        
@@ -111,32 +103,32 @@ namespace boost

        
    public: // convenience
-        reference front()
+        value_type& front()
        {
            return base::front();
        }

-        const_reference front() const
+        const value_type& front() const
        {
            return base::front();
        }

-        reference back()
+        value_type& back()
        {
            return base::back();
        }

-        const_reference back() const
+        const value_type& back() const
        {
            return base::back();
        }

-        reference operator[]( size_type sz )
+        value_type& operator[]( size_type sz )
        {
            return base::operator[](sz);
        }

-        const_reference operator[]( size_type sz ) const
+        const value_type& operator[]( size_type sz ) const
        {
            return base::operator[](sz);
        }
--- 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/Jamfile
+++ b/test/Jamfile
@@ -0,0 +1,41 @@
+# 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/
+#
+
+subproject libs/range/test ;
+
+import testing ;
+
+rule range-test ( name : includes * )
+{
+    return [
+        run $(name).cpp
+        <lib>../../test/build/boost_unit_test_framework
+        : 
+        : 
+        : <include>$(BOOST_ROOT)
+          $(includes)
+        ] ;
+}
+
+test-suite range :
+    [ range-test array ]
+    [ range-test iterator_pair ]
+    [ range-test std_container ]
+    [ range-test string ]
+    [ range-test iterator_range ]
+    [ range-test sub_range ]
+    [ range-test partial_workaround ]
+    [ range-test algorithm_example ]
+    [ range-test reversible_range ]
+    [ range-test const_ranges ]
+    [ range-test extension_mechanism ]
+#    [ range-test mfc : <include>$(VC71_ROOT)/atlmfc/include ] 
+    ;
+
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -11,7 +11,7 @@
 rule range-test ( name : includes * )
 {
    return [
-        run $(name).cpp /boost/test//boost_unit_test_framework/<link>static
+        run $(name).cpp /boost/test//boost_unit_test_framework
        : 
        : 
        : $(includes)
@@ -29,7 +29,6 @@ test-suite range :
    [ range-test algorithm_example ]
    [ range-test reversible_range ]
    [ range-test const_ranges ]
-    [ range-test extension_mechanism ]
-#    [ range-test mfc : <include>$(VC71_ROOT)/atlmfc/include ] 
+    [ range-test mfc : <include>$(VC71_ROOT)/atlmfc/include ] 
    ;

--- a/test/TODO
+++ b/test/TODO
@@ -0,0 +1 @@
+
--- a/test/compat1.cpp
+++ b/test/compat1.cpp
--- 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();
+	}

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

-        inline X::iterator boost_range_end( 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;
--- a/test/iterator_range.cpp
+++ b/test/iterator_range.cpp
@@ -1,6 +1,6 @@
 // Boost.Range library
 //
-//  Copyright Thorsten Ottosen & Larry Evans 2003-2005. Use, modification and
+//  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)
@@ -27,8 +27,6 @@
 using namespace boost;
 using namespace std;

-void check_reference_type();
-
 void check_iterator_range()
 {
   
@@ -93,8 +91,6 @@ void check_iterator_range()
    BOOST_CHECK( rrr == "ello worl" );
    rrr = make_iterator_range( rrr, -1, 1 );
    BOOST_CHECK( rrr == str );
-
-    check_reference_type();
 }


@@ -109,34 +105,3 @@ test_suite* init_unit_test_suite( int argc, char* argv[] )
    return test;
 }

-
-//
-//
-// Check that constness is propgated correct from
-// the iterator types.
-// 
-// Test contributed by Larry Evans.
-// 
-
-template< class Container >
-int test_iter_range( Container& a_cont )
-{
-    typedef BOOST_DEDUCED_TYPENAME range_result_iterator<Container>::type citer_type;
-    typedef iterator_range<citer_type> riter_type;
-    riter_type a_riter( make_iterator_range( a_cont ) );
-    a_riter.front();
-    a_riter.back();
-    int i = a_riter[0];
-    return i;
-}
-
-
-
-void check_reference_type()
-{
-    typedef vector<int> veci_type;
-    veci_type a_vec;
-    a_vec.push_back( 999 );
-    test_iter_range<veci_type>(a_vec);
-    test_iter_range<veci_type const>(a_vec);
-}
--- a/test/partial_workaround.cpp
+++ b/test/partial_workaround.cpp
@@ -90,13 +90,6 @@ void check_partial_workaround()

 }

-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-void check_partial_workaround()
-{
-}
-
-#endif

 #include <boost/test/unit_test.hpp>
 using boost::unit_test::test_suite;
@@ -109,3 +102,18 @@ test_suite* init_unit_test_suite( int argc, char* argv[] )

    return test;
 }
+
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+#include <boost/test/unit_test.hpp>
+using boost::unit_test::test_suite;
+
+test_suite* init_unit_test_suite( int, char** )
+{
+    test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
+    
+    return test;
+}
+
+#endif
+
--- a/test/sub_range.cpp
+++ b/test/sub_range.cpp
@@ -90,6 +90,17 @@ void check_sub_range()
    s.empty();
    r.size();
    s.size();
+    
+    irange singular_irange;
+    BOOST_CHECK( singular_irange.empty() );
+    BOOST_CHECK( singular_irange.size() == 0 );
+    
+    srange singular_srange;
+    BOOST_CHECK( singular_srange.empty() );
+    BOOST_CHECK( singular_srange.size() == 0 );
+
+    BOOST_CHECK( empty( singular_irange ) );
+    BOOST_CHECK( empty( singular_srange ) );

    srange rr = make_iterator_range( str );
    BOOST_CHECK( rr.equal( r ) );
Author	SHA1	Message	Date
nobody	40920f5879	This commit was manufactured by cvs2svn to create tag 'Version_1_33_1_beta'. [SVN r31604]	2005-11-08 23:18:41 +00:00
Thorsten Jørgen Ottosen	99378979c2	* empty log message * [SVN r31520]	2005-10-31 23:11:00 +00:00
John Maddock	848c11831e	Re-enable broken compiler workarounds (they cause regressions if not present). [SVN r31512]	2005-10-31 13:29:56 +00:00
Thorsten Jørgen Ottosen	823d513129	* empty log message * [SVN r30988]	2005-09-14 17:05:05 +00:00
Thorsten Jørgen Ottosen	21c1285cd0	* empty log message * [SVN r30927]	2005-09-12 20:08:14 +00:00
Thorsten Jørgen Ottosen	a47b8664f7	simplified metafunctions interface [SVN r30889]	2005-09-09 16:11:29 +00:00
Thorsten Jørgen Ottosen	19d2d83d29	added remove_const to parameters to avoid common instantiations errors [SVN r30855]	2005-09-07 16:13:23 +00:00
Thorsten Jørgen Ottosen	06e624858b	added discussion on extension mechanism [SVN r30854]	2005-09-07 16:12:03 +00:00
Thorsten Jørgen Ottosen	43a83f500e	added test for extension mechanism [SVN r30815]	2005-09-05 19:44:09 +00:00
Thorsten Jørgen Ottosen	9b66041b25	* empty log message * [SVN r30508]	2005-08-08 20:58:56 +00:00
Thorsten Jørgen Ottosen	b4f01b66bb	* empty log message * [SVN r30490]	2005-08-05 15:16:37 +00:00
Jonathan Turkanis	59f118601a	fixed broken links [SVN r30421]	2005-08-03 19:43:36 +00:00
nobody	d0f9bf8cc0	This commit was manufactured by cvs2svn to create branch 'RC_1_33_0'. [SVN r30300]	2005-07-28 18:22:24 +00:00