This commit was manufactured by cvs2svn to create branch

'python-v2-dev'. [SVN r14785]
2002-08-12 13:35:54 +00:00
13 changed files with 456 additions and 652 deletions
--- a/doc/design_decisions_rationale.html
+++ b/doc/design_decisions_rationale.html
@ -4,7 +4,7 @@
 <body bgcolor="#FFFFFF" text="#000000">
-<IMG SRC="../../../boost.png" 
+<IMG SRC="../../../c++boost.gif" 
     ALT="C++ Boost" width="277" height="86">
 <h1>Tuple Library : design decisions rationale</h1>
--- a/doc/tuple_advanced_interface.html
+++ b/doc/tuple_advanced_interface.html
@ -4,7 +4,7 @@
    <title>Tuple library advanced features</title>
 <body bgcolor="#FFFFFF" text="#000000">
-<IMG SRC="../../../boost.png" 
+<IMG SRC="../../../c++boost.gif" 
     ALT="C++ Boost" width="277" height="86">
  </head>
@ -20,9 +20,7 @@ Suppose <code>T</code> is a tuple type, and <code>N</code> is a constant integra
 <code><pre>element&lt;N, T&gt;::type</pre></code>
-gives the type of the <code>N</code>th element in the tuple type <code>T</code>. If <code>T</code> is const, the resulting type is const qualified as well. 
+gives the type of the <code>N</code>th element in the tuple type <code>T</code>.
 Note that the constness of <code>T</code> does not affect reference type
 elements.
 </p>
 <code><pre>length&lt;T&gt;::value</pre></code>
@ -101,7 +99,7 @@ For a one-element cons list the tail argument (<code>null_type</code>) can be om
 <p>
 The template <code>access_traits</code> defines three type functions. Let <code>T</code> be a type of an element in a tuple:
 <ol>
-<li><code>access_traits&lt;T&gt;::non_const_type</code> maps <code>T</code> to the return type of the non-const access functions (nonmeber and member <code>get</code> functions, and the <code>get_head</code> function).</li>
+<li><code>access_traits&lt;T&gt;::type</code> maps <code>T</code> to the return type of the non-const access functions (nonmeber and member <code>get</code> functions, and the <code>get_head</code> function).</li>
 <li><code>access_traits&lt;T&gt;::const_type</code> maps <code>T</code> to the return type of the const access functions.</li>
 <li><code>access_traits&lt;T&gt;::parameter_type</code> maps <code>T</code> to the parameter type of the tuple constructor.</li>
 </ol>
--- a/doc/tuple_users_guide.html
+++ b/doc/tuple_users_guide.html
@ -4,7 +4,7 @@
 </head>
 <body bgcolor="#FFFFFF" text="#000000">
-<IMG SRC="../../../boost.png" 
+<IMG SRC="../../../c++boost.gif" 
     ALT="C++ Boost" width="277" height="86">
 <h1>The Boost Tuple Library</h1>
@ -97,7 +97,7 @@ tuple&lt;A*, tuple&lt;const A*, const B&amp;, C&gt;, bool, void*&gt;
 <p>
 The tuple constructor takes the tuple elements as arguments. 
-For an <i>n</i>-element tuple, the constructor can be invoked with <i>k</i> arguments, where 0 &lt;= <i>k</i> &lt;= <i>n</i>.
+For an <i>n</i>-element tuple, the constructor can be invoked with <i>k</i> arguments, where 0 &lt; <i>k</i> &lt;= <i>n</i>.
 For example:
 <pre><code>tuple&lt;int, double&gt;() 
 tuple&lt;int, double&gt;(1) 
@ -202,7 +202,7 @@ Array arguments to <code>make_tuple</code> functions are deduced to reference to
 <pre><code>make_tuple(&quot;Donald&quot;, &quot;Daisy&quot;);
 </code></pre>
-This creates an object of type <code>tuple&lt;const char (&amp;)[7], const char (&amp;)[6]&gt;</code> 
+This creates an object of type <code>tuple&lt;const char (&amp;)[5], const char (&amp;)[6]&gt;</code> 
 (note that the type of a string literal is an array of const characters, not <code>const char*</code>). 
 However, to get <code>make_tuple</code> to create a tuple with an element of a
 non-const array type one must use the <code>ref</code> wrapper.
@ -264,10 +264,10 @@ A tuple can be copy constructed from another tuple, provided that the element ty
 Analogously, a tuple can be assigned to another tuple, provided that the element types are element-wise assignable.
 For example:
-<pre><code>class A {};
+<pre><code>class A;
 class B : public A {};
-struct C { C(); C(const B&amp;); };
+struct C { C(); C(const B&amp;); }
-struct D { operator C() const; };
+struct D { operator C() const; }
 tuple&lt;char, B*, B, D&gt; t;
  ...
 tuple&lt;int, A*, C, C&gt; a(t); // ok 
@ -460,8 +460,8 @@ f1(i,d);         // #1
 tie(i,d) = f2(); // #2
 </code></pre>
 See 
-[<a href="#publ_1">1</a>,
+[<a href=#publ_1>1</a>,
-<a href="#publ_2">2</a>]
+<a href=#publ_2>2</a>]
 for more in-depth discussions about efficiency.
 <h4>Effect on Compile Time</h4>
@ -472,8 +472,8 @@ Depending on the compiler and the tuple length, it may be more than 10 times slo
 However, as a realistic program is likely to contain a lot of code in addition to tuple definitions, the difference is probably unnoticeable.
 Compile time increases between 5 to 10 percentages were measured for programs which used tuples very frequently.
 With the same test programs, memory consumption of compiling increased between 22% to 27%. See  
-[<a href="#publ_1">1</a>,
+[<a href=#publ_1>1</a>,
-<a href="#publ_2">2</a>]
+<a href=#publ_2>2</a>]
 for details.
 </p>
@ -492,7 +492,7 @@ Below is a list of compilers and known problems with each compiler:
 </table>
 <h2><a name = "thanks">Acknowledgements</a></h2>
-Gary Powell has been an indispensable helping hand. In particular, stream manipulators for tuples were his idea. Doug Gregor came up with a working version for MSVC, David Abrahams found a way to get rid of most of the restrictions for compilers not supporting partial specialization. Thanks to Jeremy Siek, William Kempf and Jens Maurer for their help and suggestions. 
+Gary Powell has been an indispensable helping hand. In particular, stream manipulators for tuples were his idea. Doug Gregor came up with a working version for MSVC. Thanks to Jeremy Siek, William Kempf and Jens Maurer for their help and suggestions. 
 The comments by Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes, David Abrahams and Hartmut Kaiser helped to improve the
 library.
 The idea for the tie mechanism came from an old usenet article by Ian McCulloch, where he proposed something similar for std::pairs.
@ -500,12 +500,12 @@ The idea for the tie mechanism came from an old usenet article by Ian McCulloch,
 <p>
 <a name="publ_1"></a>[1]
-J&auml;rvi J.: <i>Tuples and multiple return values in C++</i>, TUCS Technical Report No 249, 1999<!-- (<a href="http://www.tucs.fi/Publications">http://www.tucs.fi/Publications</a>)-->.
+J&auml;rvi J.: <i>Tuples and multiple return values in C++</i>, TUCS Technical Report No 249, 1999 (<a href="http://www.tucs.fi/publications">http://www.tucs.fi/publications</a>).
 </p>
 <p>
 <a name="publ_2"></a>[2]
-J&auml;rvi J.: <i>ML-Style Tuple Assignment in Standard C++ - Extending the Multiple Return Value Formalism</i>, TUCS Technical Report No 267, 1999<!-- (<a href="http://www.tucs.fi/Publications">http://www.tucs.fi/Publications</a>)-->.
+J&auml;rvi J.: <i>ML-Style Tuple Assignment in Standard C++ - Extending the Multiple Return Value Formalism</i>, TUCS Technical Report No 267, 1999 (<a href="http://www.tucs.fi/publications">http://www.tucs.fi/publications</a>).
 </p>
 <p>
@ -514,7 +514,7 @@ J&auml;rvi J.: <i>ML-Style Tuple Assignment in Standard C++ - Extending the Mult
 <hr>
-<p>Last modified 2003-09-07</p>
+<p>Last modified 2001-09-13</p>
 <p>&copy; Copyright <a href="../../../people/jaakko_jarvi.htm"> Jaakko J&auml;rvi</a> 2001. 
--- a/include/boost/tuple/detail/tuple_basic.hpp
+++ b/include/boost/tuple/detail/tuple_basic.hpp
@ -2,9 +2,14 @@
 // Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //
-// Distributed under the Boost Software License, Version 1.0. (See
+// Permission to copy, use, sell and distribute this software is granted
-// accompanying file LICENSE_1_0.txt or copy at
+// provided this copyright notice appears in all copies. 
-// http://www.boost.org/LICENSE_1_0.txt)
+// Permission to modify the code and to distribute modified code is granted
 // provided this copyright notice appears in all copies, and a notice 
 // that the code was modified is included with the copyright notice.
 //
 // This software is provided "as is" without express or implied warranty, 
 // and with no claim as to its suitability for any purpose.
 // For more information, see http://www.boost.org
@ -13,8 +18,8 @@
 // Fixed return types for get_head/get_tail 
 // ( and other bugs ) per suggestion of Jens Maurer
 // simplified element type accessors + bug fix  (Jeremy Siek)
-// Several changes/additions according to suggestions by Douglas Gregor,
+// Several changes/additions according to suggestions by Doug Gregor, 
-// William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes,
+// William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Davis,
 // David Abrahams.
 // Revision history:
@ -38,8 +43,6 @@
 #include "boost/type_traits/cv_traits.hpp"
 #include "boost/type_traits/function_traits.hpp"
 #include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND
 namespace boost {
 namespace tuples {
@ -81,6 +84,17 @@ template<class T> struct length;
 namespace detail {
 #ifdef BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
  template<int N> struct workaround_holder {};
 #  define BOOST_TUPLE_DUMMY_PARM        , detail::workaround_holder<N>* = 0
 #  define BOOST_TUPLE_SINGLE_DUMMY_PARM detail::workaround_holder<N>* = 0
 #else
 #  define BOOST_TUPLE_DUMMY_PARM
 #  define BOOST_TUPLE_SINGLE_DUMMY_PARM
 #endif
 // -- generate error template, referencing to non-existing members of this 
 // template is used to produce compilation errors intentionally
 template<class T>
@ -94,22 +108,12 @@ struct get_class {
  template<class RET, class HT, class TT >
  inline static RET get(const cons<HT, TT>& t)
  {
-#if BOOST_WORKAROUND(__IBMCPP__,==600)
+    return get_class<N-1>::template get<RET>(t.tail);
    // vacpp 6.0 is not very consistent regarding the member template keyword
    // Here it generates an error when the template keyword is used.
    return get_class<N-1>::get<RET>(t.tail);
 #else
    return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
 #endif
  }
  template<class RET, class HT, class TT >
  inline static RET get(cons<HT, TT>& t)
  {
-#if BOOST_WORKAROUND(__IBMCPP__,==600)
+    return get_class<N-1>::template get<RET>(t.tail);
    return get_class<N-1>::get<RET>(t.tail);
 #else
    return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
 #endif
  }
 };
@ -135,8 +139,6 @@ struct get_class<0> {
 // Nth element ot T, first element is at index 0
 // -------------------------------------------------------
 #ifndef BOOST_NO_CV_SPECIALIZATIONS
 template<int N, class T>
 struct element
 {
@ -151,76 +153,6 @@ struct element<0,T>
  typedef typename T::head_type type;
 };
 template<int N, class T>
 struct element<N, const T>
 {
 private:
  typedef typename T::tail_type Next;
  typedef typename element<N-1, Next>::type unqualified_type;
 public:
 #if BOOST_WORKAROUND(__BORLANDC__,<0x600)
  typedef const unqualified_type type;
 #else
  typedef typename boost::add_const<unqualified_type>::type type;
 #endif
 };
 template<class T>
 struct element<0,const T>
 {
 #if BOOST_WORKAROUND(__BORLANDC__,<0x600)
  typedef const typename T::head_type type;
 #else
  typedef typename boost::add_const<typename T::head_type>::type type;
 #endif
 };
 #else // def BOOST_NO_CV_SPECIALIZATIONS
 namespace detail {
 template<int N, class T, bool IsConst>
 struct element_impl
 {
 private:
  typedef typename T::tail_type Next;
 public:
  typedef typename element_impl<N-1, Next, IsConst>::type type;
 };
 template<int N, class T>
 struct element_impl<N, T, true /* IsConst */>
 {
 private:
  typedef typename T::tail_type Next;
 public:
  typedef const typename element_impl<N-1, Next, true>::type type;
 };
 template<class T>
 struct element_impl<0, T, false /* IsConst */>
 {
  typedef typename T::head_type type;
 };
 template<class T>
 struct element_impl<0, T, true /* IsConst */>
 {
  typedef const typename T::head_type type;
 };
 } // end of namespace detail
 template<int N, class T>
 struct element: 
  public detail::element_impl<N, T, ::boost::is_const<T>::value>
 {
 };
 #endif
 // -get function templates -----------------------------------------------
 // Usage: get<N>(aTuple)
@ -257,18 +189,12 @@ template<int N, class HT, class TT>
 inline typename access_traits<
                  typename element<N, cons<HT, TT> >::type
                >::non_const_type
-get(cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+get(cons<HT, TT>& c BOOST_TUPLE_DUMMY_PARM) { 
-#if BOOST_WORKAROUND(__IBMCPP__,==600 )
+  return detail::get_class<N>::template 
  return detail::get_class<N>::
 #else
  return detail::get_class<N>::BOOST_NESTED_TEMPLATE
 #endif
         get<
           typename access_traits<
             typename element<N, cons<HT, TT> >::type
-           >::non_const_type,
+           >::non_const_type>(c); 
           HT,TT
         >(c);
 } 
 // get function for const cons-lists, returns a const reference to
@ -278,18 +204,12 @@ template<int N, class HT, class TT>
 inline typename access_traits<
                  typename element<N, cons<HT, TT> >::type
                >::const_type
-get(const cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+get(const cons<HT, TT>& c BOOST_TUPLE_DUMMY_PARM) { 
-#if BOOST_WORKAROUND(__IBMCPP__,==600)
+  return detail::get_class<N>::template 
  return detail::get_class<N>::
 #else
  return detail::get_class<N>::BOOST_NESTED_TEMPLATE
 #endif
         get<
           typename access_traits<
             typename element<N, cons<HT, TT> >::type
-           >::const_type,
+         >::const_type>(c);
           HT,TT
         >(c);
 } 
 // -- the cons template  --------------------------------------------------
@ -362,7 +282,7 @@ struct cons {
  template <class T2, class T3, class T4, class T5, 
            class T6, class T7, class T8, class T9, class T10>
-  cons( const null_type& /*t1*/, T2& t2, T3& t3, T4& t4, T5& t5,
+  cons( const null_type& t1, T2& t2, T3& t3, T4& t4, T5& t5, 
        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 ) 
    : head (), 
      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
@ -412,7 +332,6 @@ struct cons<HT, null_type> {
  typedef HT head_type;
  typedef null_type tail_type;
  typedef cons<HT, null_type> self_type;
  typedef typename 
    detail::wrap_non_storeable_type<head_type>::type stored_head_type;
@ -441,7 +360,7 @@ struct cons<HT, null_type> {
       const null_type&, const null_type&, const null_type&)
  : head (t1) {}
-  cons(const null_type&,
+  cons(const null_type& t1, 
       const null_type&, const null_type&, const null_type&, 
       const null_type&, const null_type&, const null_type&, 
       const null_type&, const null_type&, const null_type&)
@ -460,17 +379,17 @@ struct cons<HT, null_type> {
  template <int N>
  typename access_traits<
-             typename element<N, self_type>::type
+             typename element<N, cons>::type
            >::non_const_type
-  get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+  get(BOOST_TUPLE_SINGLE_DUMMY_PARM) {
    return boost::tuples::get<N>(*this);
  }
  template <int N>
  typename access_traits<
-             typename element<N, self_type>::type
+             typename element<N, cons>::type
           >::const_type
-  get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) const {
+  get(BOOST_TUPLE_SINGLE_DUMMY_PARM) const {
    return boost::tuples::get<N>(*this);
  }
@ -657,7 +576,7 @@ namespace detail {
 struct swallow_assign {
  template<typename T>
-  swallow_assign const& operator=(const T&) const {
+  swallow_assign& operator=(const T&) {
    return *this;
  }
 };
@ -665,7 +584,9 @@ struct swallow_assign {
 } // namespace detail
 // "ignore" allows tuple positions to be ignored when using "tie". 
-detail::swallow_assign const ignore = detail::swallow_assign();
+namespace {
 detail::swallow_assign ignore;
 }
 // ---------------------------------------------------------------------------
 // The call_traits for make_tuple
@ -938,6 +859,8 @@ tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
 } // end of namespace tuples
 } // end of namespace boost
 #undef BOOST_TUPLE_DUMMY_PARM
 #undef BOOST_TUPLE_SINGLE_DUMMY_PARM
 #endif // BOOST_TUPLE_BASIC_HPP
--- a/include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp
+++ b/include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp
@ -1,12 +1,17 @@
 // - tuple_basic_no_partial_spec.hpp -----------------------------------------
 // Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2001 Douglas Gregor (gregod@rpi.edu)
+// Copyright (C) 2001 Doug Gregor (gregod@rpi.edu)
 // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
 //
-// Distributed under the Boost Software License, Version 1.0. (See
+// Permission to copy, use, sell and distribute this software is granted
-// accompanying file LICENSE_1_0.txt or copy at
+// provided this copyright notice appears in all copies. 
-// http://www.boost.org/LICENSE_1_0.txt)
+// Permission to modify the code and to distribute modified code is granted
 // provided this copyright notice appears in all copies, and a notice 
 // that the code was modified is included with the copyright notice.
 //
 // This software is provided "as is" without express or implied warranty, 
 // and with no claim as to its suitability for any purpose.
 // For more information, see http://www.boost.org or http://lambda.cs.utu.fi 
@ -63,10 +68,6 @@ namespace tuples {
    >
    class tuple;
 // forward declaration of cons
    template<typename Head, typename Tail = null_type>
    struct cons;
    namespace detail {
      // Takes a pointer and routes all assignments to whatever it points to
@ -91,125 +92,57 @@ namespace tuples {
      struct swallow_assign
      {
        template<typename T>
-        swallow_assign const& operator=(const T&) const
+        swallow_assign& operator=(const T&)
        {
          return *this;
        }
      };
    template <typename T> struct add_const_reference : add_reference<typename add_const<T>::type> {};
    template <class MyTail>
    struct init_tail
    {
        // Each of vc6 and vc7 seem to require a different formulation
        // of this return type
        template <class H, class T>
 #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
        static typename add_reference<typename add_const<T>::type>::type
 #else
        static typename add_const_reference<T>::type
 #endif
        execute( cons<H,T> const& u, long )
        {
            return u.get_tail();
        }
    };
    template <>
    struct init_tail<null_type>
    {
        template <class H>
        static null_type execute( cons<H,null_type> const& u, long )
        {
            return null_type();
        }
        template <class U>
        static null_type execute(U const&, ...)
        {
            return null_type();
        }
     private:
        template <class H, class T>
        void execute( cons<H,T> const&, int);
    };
    template <class Other>
    Other const&
    init_head( Other const& u, ... )
    {
        return u;
    }
    template <class H, class T>
    typename add_reference<typename add_const<H>::type>::type
    init_head( cons<H,T> const& u, int )
    {
        return u.get_head();
    }
    inline char**** init_head(null_type const&, int);
  } // end of namespace detail
    // cons builds a heterogenous list of types
-   template<typename Head, typename Tail>
+   template<typename Head, typename Tail = null_type>
   struct cons
   {
     typedef cons self_type;
     typedef Head head_type;
     typedef Tail tail_type;
    private:
       typedef typename boost::add_reference<head_type>::type head_ref;
       typedef typename boost::add_reference<tail_type>::type tail_ref;
       typedef typename detail::add_const_reference<head_type>::type head_cref;
       typedef typename detail::add_const_reference<tail_type>::type tail_cref;
    public:
     head_type head;
     tail_type tail;
-     head_ref get_head() { return head; }
+     typename boost::add_reference<head_type>::type get_head() { return head; }
-     tail_ref get_tail() { return tail; }
+     typename boost::add_reference<tail_type>::type get_tail() { return tail; }  
-     head_cref get_head() const { return head; }
+     typename boost::add_reference<const head_type>::type get_head() const { return head; }
-     tail_cref get_tail() const { return tail; }
+     typename boost::add_reference<const tail_type>::type get_tail() const { return tail; }
     cons() : head(), tail() {}
 #if defined BOOST_MSVC
      template<typename Tail>
-      cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
+      explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
                    const Tail& t) : head(h), tail(t.head, t.tail)
      {
      }
-      cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
+      explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
                    const null_type& t) : head(h), tail(t)
      {
      }
 #else
      template<typename T>
-      explicit cons(head_cref h, const T& t) :
+      explicit cons(const head_type& h, const T& t) : 
        head(h), tail(t.head, t.tail)
      {
      }
-      explicit cons(head_cref h = head_type(),
+      explicit cons(const head_type& h = head_type(),
-                    tail_cref t = tail_type()) :
+                    const tail_type& t = tail_type()) :
        head(h), tail(t)
      {
      }
 #endif
      template <class U>
      cons( const U& u )
        : head(detail::init_head(u, 0))
        , tail(detail::init_tail<Tail>::execute(u, 0L))
       {
       }
      template<typename Other>
      cons& operator=(const Other& other)
@ -483,45 +416,26 @@ namespace tuples {
      typedef typename mapped_tuple::cons2 cons2;
      typedef typename mapped_tuple::cons1 cons1;
      typedef typename detail::add_const_reference<T1>::type t1_cref;
      typedef typename detail::add_const_reference<T2>::type t2_cref;
      typedef typename detail::add_const_reference<T3>::type t3_cref;
      typedef typename detail::add_const_reference<T4>::type t4_cref;
      typedef typename detail::add_const_reference<T5>::type t5_cref;
      typedef typename detail::add_const_reference<T6>::type t6_cref;
      typedef typename detail::add_const_reference<T7>::type t7_cref;
      typedef typename detail::add_const_reference<T8>::type t8_cref;
      typedef typename detail::add_const_reference<T9>::type t9_cref;
      typedef typename detail::add_const_reference<T10>::type t10_cref;
    public:
      typedef cons1 inherited;
      typedef tuple self_type;
-      tuple() : cons1(T1(), cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
+      explicit tuple(const T1& t1 = T1(), 
-        {}
+                     const T2& t2 = T2(),
-
+                     const T3& t3 = T3(),
-      tuple(
+                     const T4& t4 = T4(),
-          t1_cref t1,
+                     const T5& t5 = T5(),
-          t2_cref t2,
+                     const T6& t6 = T6(),
-          t3_cref t3 = T3(),
+                     const T7& t7 = T7(),
-          t4_cref t4 = T4(),
+                     const T8& t8 = T8(),
-          t5_cref t5 = T5(),
+                     const T9& t9 = T9(),
-          t6_cref t6 = T6(),
+                     const T10& t10 = T10()) :
          t7_cref t7 = T7(),
          t8_cref t8 = T8(),
          t9_cref t9 = T9(),
          t10_cref t10 = T10()
      ) :
        cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10))))))))))
      {
      }
      explicit tuple(t1_cref t1)
        : cons1(t1, cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
      {}
      template<typename Head, typename Tail>
-      tuple(const cons<Head, Tail>& other) :
+      explicit tuple(const cons<Head, Tail>& other) : 
        cons1(other.head, other.tail)
      {
      }
@ -833,8 +747,9 @@ namespace tuples {
                        detail::assign_to_pointee<T10>(&t10));
    }
    // "ignore" allows tuple positions to be ignored when using "tie". 
-
+    namespace {
-detail::swallow_assign const ignore = detail::swallow_assign();
+      detail::swallow_assign ignore;
    }
 } // namespace tuples
 } // namespace boost
--- a/include/boost/tuple/tuple.hpp
+++ b/include/boost/tuple/tuple.hpp
@ -2,9 +2,14 @@
 // Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //
-// Distributed under the Boost Software License, Version 1.0. (See
+// Permission to copy, use, sell and distribute this software is granted
-// accompanying file LICENSE_1_0.txt or copy at
+// provided this copyright notice appears in all copies. 
-// http://www.boost.org/LICENSE_1_0.txt)
+// Permission to modify the code and to distribute modified code is granted
 // provided this copyright notice appears in all copies, and a notice 
 // that the code was modified is included with the copyright notice.
 //
 // This software is provided "as is" without express or implied warranty, 
 // and with no claim as to its suitability for any purpose.
 // For more information, see http://www.boost.org
@ -13,13 +18,6 @@
 #ifndef BOOST_TUPLE_HPP
 #define BOOST_TUPLE_HPP
 #if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
 // Work around a compiler bug.
 // boost::python::tuple has to be seen by the compiler before the
 // boost::tuple class template.
 namespace boost { namespace python { class tuple; }}
 #endif
 #include "boost/config.hpp"
 #include "boost/static_assert.hpp"
--- a/include/boost/tuple/tuple_comparison.hpp
+++ b/include/boost/tuple/tuple_comparison.hpp
@ -3,9 +3,14 @@
 // Copyright (C) 2001 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
 //
-// Distributed under the Boost Software License, Version 1.0. (See
+// Permission to copy, use, sell and distribute this software is granted
-// accompanying file LICENSE_1_0.txt or copy at
+// provided this copyright notice appears in all copies. 
-// http://www.boost.org/LICENSE_1_0.txt)
+// Permission to modify the code and to distribute modified code is granted
 // provided this copyright notice appears in all copies, and a notice 
 // that the code was modified is included with the copyright notice.
 // 
 // This software is provided "as is" without express or implied warranty, 
 // and with no claim as to its suitability for any purpose.
 // 
 // For more information, see http://www.boost.org
 // 
--- a/include/boost/tuple/tuple_io.hpp
+++ b/include/boost/tuple/tuple_io.hpp
@ -3,9 +3,14 @@
 // Copyright (C) 2001 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //               2001 Gary Powell (gary.powell@sierra.com)
 //
-// Distributed under the Boost Software License, Version 1.0. (See
+// Permission to copy, use, sell and distribute this software is granted
-// accompanying file LICENSE_1_0.txt or copy at
+// provided this copyright notice appears in all copies. 
-// http://www.boost.org/LICENSE_1_0.txt)
+// Permission to modify the code and to distribute modified code is granted
 // provided this copyright notice appears in all copies, and a notice 
 // that the code was modified is included with the copyright notice.
 //
 // This software is provided "as is" without express or implied warranty, 
 // and with no claim as to its suitability for any purpose.
 // For more information, see http://www.boost.org 
 // ----------------------------------------------------------------------------
@ -31,23 +36,6 @@
 #include "boost/tuple/tuple.hpp"
 // This is ugly: one should be using twoargument isspace since whitspace can
 // be locale dependent, in theory at least.
 // not all libraries implement have the two-arg version, so we need to 
 // use the one-arg one, which one should get with <cctype> but there seem
 // to be exceptions to this.
 #if !defined (BOOST_NO_STD_LOCALE)
 #include <locale> // for two-arg isspace
 #else 
 #include <cctype> // for one-arg (old) isspace 
 #include <ctype.h> // Metrowerks does not find one-arg isspace from cctype
 #endif
 namespace boost {
 namespace tuples {
@ -81,9 +69,9 @@ public:
     // parentheses and space are the default manipulators
     if (!c) {
       switch(m) {
-         case detail::format_info::open : c = '('; break;
+         case open : c = '('; break;
-         case detail::format_info::close : c = ')'; break;
+         case close : c = ')'; break;
-         case detail::format_info::delimiter : c = ' '; break;
+         case delimiter : c = ' '; break;
       }
     }
     return c;
@ -104,9 +92,9 @@ public:
     // parentheses and space are the default manipulators
     if (!c) {
       switch(m) {
-         case detail::format_info::open :  c = i.widen('('); break;
+         case open :  c = i.widen('('); break;
-         case detail::format_info::close : c = i.widen(')'); break;
+         case close : c = i.widen(')'); break;
-         case detail::format_info::delimiter : c = i.widen(' '); break;
+         case delimiter : c = i.widen(' '); break;
       }
     }
     return c;
@ -340,16 +328,12 @@ extract_and_check_delimiter(
 {
  const char d = format_info::get_manipulator(is, del);
-#if defined (BOOST_NO_STD_LOCALE)
+  const bool is_delimiter = (!isspace(d) );      
  const bool is_delimiter = !isspace(d);
 #else
  const bool is_delimiter = (!std::isspace(d, is.getloc()) );            
 #endif
  char c;
  if (is_delimiter) { 
    is >> c; 
-    if (is.good() && c!=d) {
+    if (c!=d) {
      is.setstate(std::ios::failbit);
    } 
  }
@ -431,19 +415,12 @@ extract_and_check_delimiter(
 {
  const CharType d = format_info::get_manipulator(is, del);
-#if defined (BOOST_NO_STD_LOCALE)
+  const bool is_delimiter = (!isspace(d) );      
  const bool is_delimiter = !isspace(d);
 #elif defined ( __BORLANDC__ )
  const bool is_delimiter = !std::use_facet< std::ctype< CharType > >
    (is.getloc() ).is( std::ctype_base::space, d);
 #else
  const bool is_delimiter = (!std::isspace(d, is.getloc()) );            
 #endif
  CharType c;
  if (is_delimiter) { 
    is >> c;
-    if (is.good() && c!=d) { 
+    if (c!=d) { 
      is.setstate(std::ios::failbit);
    }
  }
--- a/index.html
+++ b/index.html
@ -1,13 +0,0 @@
 <html>
 <head>
 <meta http-equiv="refresh" content="0; URL=doc/tuple_users_guide.html">
 </head>
 <body>
 Automatic redirection failed, please go to <a href="doc/tuple_users_guide.html">doc/tuple_users_guide.html</a> 
 &nbsp;<hr>
 <p><EFBFBD> Copyright Beman Dawes, 2001</p>
 <p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
 file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
 at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
 </body>
 </html>
--- a/test/Jamfile
+++ b/test/Jamfile
@ -1,8 +0,0 @@
 project : requirements <library>/boost/test//boost_test_exec_monitor ;
 test-suite tuple : 
    [ run tuple_test_bench.cpp ]
    [ run io_test.cpp ]
    [ run another_tuple_test_bench.cpp ]
    ;
--- a/test/another_tuple_test_bench.cpp
+++ b/test/another_tuple_test_bench.cpp
@ -1,12 +1,3 @@
 // Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under 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
 //  another_test_bench.cpp  --------------------------------
 // This file has various tests to see that things that shouldn't
@ -98,11 +89,12 @@ void foo2() {
 void foo4() 
 {
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  double d = 2.7; 
  A a;
  tuple<int, double&, const A&> t(1, d, a);
  const tuple<int, double&, const A> ct = t;
-  (void)ct;
+
 #ifdef E8
  get<0>(ct) = 5; // can't assign to const
 #endif
@ -113,6 +105,8 @@ void foo4()
 #ifdef E10
  dummy(get<5>(ct)); // illegal index
 #endif
 #endif
 }
 // testing copy and assignment with implicit conversions between elements
@ -125,10 +119,9 @@ void foo4()
  void foo5() {
    tuple<char, BB*, BB, DD> t;
-    (void)t;
+
    tuple<char, char> aaa;
    tuple<int, int> bbb(aaa);
    (void)bbb;
    //    tuple<int, AA*, CC, CC> a = t;
    //    a = t;
  }
--- a/test/io_test.cpp
+++ b/test/io_test.cpp
@ -1,11 +1,3 @@
 // Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under 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
 // -- io_test.cpp -----------------------------------------------
 //
 // Testing the I/O facilities of tuples
@ -27,6 +19,8 @@
 #include <sstream>
 #endif
 #include "boost/config.hpp"
 using namespace std;
 using namespace boost;
@ -39,8 +33,7 @@ typedef istringstream useThisIStringStream;
 #endif
 int test_main(int argc, char * argv[] ) {
-   (void)argc;
+
   (void)argv;
   using boost::tuples::set_close;
   using boost::tuples::set_open;
   using boost::tuples::set_delimiter;
@ -52,7 +45,7 @@ int test_main(int argc, char * argv[] ) {
  os1 << set_close(']');
  os1 << set_delimiter(',');
  os1 << make_tuple(1, 2, 3);
-  BOOST_CHECK (os1.str() == std::string("[1,2,3]") );
+  BOOST_TEST (os1.str() == std::string("[1,2,3]") );
  {
  useThisOStringStream os2;
@ -62,13 +55,13 @@ int test_main(int argc, char * argv[] ) {
  os2 << set_delimiter(':');
 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  os2 << make_tuple("TUPU", "HUPU", "LUPU", 4.5);
-  BOOST_CHECK (os2.str() == std::string("(TUPU:HUPU:LUPU:4.5)") );
+  BOOST_TEST (os2.str() == std::string("(TUPU:HUPU:LUPU:4.5)") );
 #endif
  }
  // The format is still [a, b, c] for os1
  os1 << make_tuple(1, 2, 3);
-  BOOST_CHECK (os1.str() == std::string("[1,2,3][1,2,3]") );
+  BOOST_TEST (os1.str() == std::string("[1,2,3][1,2,3]") );
  ofstream tmp("temp.tmp");
@ -86,13 +79,13 @@ int test_main(int argc, char * argv[] ) {
 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  tmp3 >> j; 
-  BOOST_CHECK (tmp3.good() ); 
+  BOOST_TEST (tmp3.good() ); 
 #endif
  tmp3 >> set_delimiter(':');
  tuple<int, int, int> i;
  tmp3 >> i; 
-  BOOST_CHECK (tmp3.good() ); 
+  BOOST_TEST (tmp3.good() ); 
  tmp3.close(); 
@ -101,8 +94,8 @@ int test_main(int argc, char * argv[] ) {
  useThisIStringStream is("(100 200 300)"); 
  tuple<int, int, int> ti; 
-  BOOST_CHECK(bool(is >> ti));
+  BOOST_TEST(is >> ti);
-  BOOST_CHECK(ti == make_tuple(100, 200, 300));
+  BOOST_TEST(ti == make_tuple(100, 200, 300));
  // Note that strings are problematic:
--- a/test/tuple_test_bench.cpp
+++ b/test/tuple_test_bench.cpp
@ -1,11 +1,3 @@
 // Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under 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
 //  tuple_test_bench.cpp  --------------------------------
 #define BOOST_INCLUDE_MAIN  // for testing, include rather than link
@ -15,9 +7,6 @@
 #include "boost/tuple/tuple_comparison.hpp"
 #include "boost/type_traits/is_const.hpp"
 #include "boost/ref.hpp"
 #include <string>
 #include <utility>
@ -77,6 +66,7 @@ public:
 typedef tuple<int> t1;
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 typedef tuple<double&, const double&, const double, double*, const double*> t2;
 typedef tuple<A, int(*)(char, int), C> t3;
 typedef tuple<std::string, std::pair<A, B> > t4;
@ -87,16 +77,22 @@ typedef tuple<volatile int, const volatile char&, int(&)(float) > t6;
 typedef tuple<B(A::*)(C&), A&> t7;
 #endif
 #endif
 // -----------------------------------------------------------------------
 // -tuple construction tests ---------------------------------------------
 // -----------------------------------------------------------------------
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 no_copy y;
 tuple<no_copy&> x = tuple<no_copy&>(y); // ok
 #endif
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 char cs[10];
 tuple<char(&)[10]> v2(cs);  // ok
 #endif
 void
 construction_test()
@ -107,32 +103,32 @@ construction_test()
  // MSVC 6.0 just cannot find get without the namespace qualifier
  tuple<int> t1;
-  BOOST_CHECK(get<0>(t1) == int());
+  BOOST_TEST(get<0>(t1) == int());
  tuple<float> t2(5.5f);
-  BOOST_CHECK(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f);
+  BOOST_TEST(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f);
  tuple<foo> t3(foo(12));
-  BOOST_CHECK(get<0>(t3) == foo(12));
+  BOOST_TEST(get<0>(t3) == foo(12));
  tuple<double> t4(t2);
-  BOOST_CHECK(get<0>(t4) > 5.4 && get<0>(t4) < 5.6);
+  BOOST_TEST(get<0>(t4) > 5.4 && get<0>(t4) < 5.6);
  tuple<int, float> t5;
-  BOOST_CHECK(get<0>(t5) == int());
+  BOOST_TEST(get<0>(t5) == int());
-  BOOST_CHECK(get<1>(t5) == float());
+  BOOST_TEST(get<1>(t5) == float());
  tuple<int, float> t6(12, 5.5f);
-  BOOST_CHECK(get<0>(t6) == 12);
+  BOOST_TEST(get<0>(t6) == 12);
-  BOOST_CHECK(get<1>(t6) > 5.4f && get<1>(t6) < 5.6f);
+  BOOST_TEST(get<1>(t6) > 5.4f && get<1>(t6) < 5.6f);
  tuple<int, float> t7(t6);
-  BOOST_CHECK(get<0>(t7) == 12);
+  BOOST_TEST(get<0>(t7) == 12);
-  BOOST_CHECK(get<1>(t7) > 5.4f && get<1>(t7) < 5.6f);
+  BOOST_TEST(get<1>(t7) > 5.4f && get<1>(t7) < 5.6f);
  tuple<long, double> t8(t6);
-  BOOST_CHECK(get<0>(t8) == 12);
+  BOOST_TEST(get<0>(t8) == 12);
-  BOOST_CHECK(get<1>(t8) > 5.4f && get<1>(t8) < 5.6f);
+  BOOST_TEST(get<1>(t8) > 5.4f && get<1>(t8) < 5.6f);
  dummy(
    tuple<no_def_constructor, no_def_constructor, no_def_constructor>(
@ -151,10 +147,12 @@ construction_test()
  //  dummy(tuple<double&>()); // should fail, not defaults for references
  //  dummy(tuple<const double&>()); // likewise
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  double dd = 5;
  dummy(tuple<double&>(dd)); // ok
  dummy(tuple<const double&>(dd+3.14)); // ok, but dangerous
 #endif
  //  dummy(tuple<double&>(dd+3.14)); // should fail,
  //                                  // temporary to non-const reference
@ -167,6 +165,7 @@ construction_test()
 void element_access_test()
 {
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  double d = 2.7;
  A a;
  tuple<int, double&, const A&, int> t(1, d, a, 2);
@ -175,40 +174,58 @@ void element_access_test()
  int i  = get<0>(t);
  int i2 = get<3>(t);
-  BOOST_CHECK(i == 1 && i2 == 2);
+  BOOST_TEST(i == 1 && i2 == 2);
  int j  = get<0>(ct);
-  BOOST_CHECK(j == 1);
+  BOOST_TEST(j == 1);
  get<0>(t) = 5;
-  BOOST_CHECK(t.head == 5);
+  BOOST_TEST(t.head == 5);
  //  get<0>(ct) = 5; // can't assign to const
  double e = get<1>(t);
-  BOOST_CHECK(e > 2.69 && e < 2.71);
+  BOOST_TEST(e > 2.69 && e < 2.71);
  get<1>(t) = 3.14+i;
-  BOOST_CHECK(get<1>(t) > 4.13 && get<1>(t) < 4.15);
+  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
  //  get<4>(t) = A(); // can't assign to const
  //  dummy(get<5>(ct)); // illegal index
  ++get<0>(t);
-  BOOST_CHECK(get<0>(t) == 6);
+  BOOST_TEST(get<0>(t) == 6);
  BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<0, tuple<int, float> >::type>::value != true));
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
  BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<0, const tuple<int, float> >::type>::value));
 #endif 
  BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<1, tuple<int, float> >::type>::value != true));
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
  BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<1, const tuple<int, float> >::type>::value));
 #endif 
  dummy(i); dummy(i2); dummy(j); dummy(e); // avoid warns for unused variables
 #else
  double d = 2.7; 
  A a;
  tuple<int, double, const A, int> t(1, d, a, 2);
  int i  = get<0>(t);
  int i2 = get<3>(t);
  BOOST_TEST(i == 1 && i2 == 2);
  get<0>(t) = 5;
  BOOST_TEST(t.head == 5);
  //  get<0>(ct) = 5; // can't assign to const
  double e = get<1>(t);
  BOOST_TEST(e > 2.69 && e < 2.71);
  get<1>(t) = 3.14+i;
  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
  //  get<4>(t) = A(); // can't assign to const
  //  dummy(get<5>(ct)); // illegal index
  ++get<0>(t);
  BOOST_TEST(get<0>(t) == 6);
  dummy(i); dummy(i2); dummy(e); // avoid warns for unused variables
 #endif
 }
@ -224,13 +241,13 @@ copy_test()
  tuple<int, char> t1(4, 'a');
  tuple<int, char> t2(5, 'b');
  t2 = t1;
-  BOOST_CHECK(get<0>(t1) == get<0>(t2));
+  BOOST_TEST(get<0>(t1) == get<0>(t2));
-  BOOST_CHECK(get<1>(t1) == get<1>(t2));
+  BOOST_TEST(get<1>(t1) == get<1>(t2));
  tuple<long, std::string> t3(2, "a");
  t3 = t1;
-  BOOST_CHECK((double)get<0>(t1) == get<0>(t3));
+  BOOST_TEST((double)get<0>(t1) == get<0>(t3));
-  BOOST_CHECK(get<1>(t1) == get<1>(t3)[0]);
+  BOOST_TEST(get<1>(t1) == get<1>(t3)[0]);
 // testing copy and assignment with implicit conversions between elements
 // testing tie
@ -242,9 +259,9 @@ copy_test()
  int i; char c; double d;
  tie(i, c, d) = make_tuple(1, 'a', 5.5);
-  BOOST_CHECK(i==1);
+  BOOST_TEST(i==1);
-  BOOST_CHECK(c=='a');
+  BOOST_TEST(c=='a');
-  BOOST_CHECK(d>5.4 && d<5.6);
+  BOOST_TEST(d>5.4 && d<5.6);
 }
 void
@ -256,10 +273,10 @@ mutate_test()
  get<2>(t1) = false;
  get<3>(t1) = foo(5);
-  BOOST_CHECK(get<0>(t1) == 6);
+  BOOST_TEST(get<0>(t1) == 6);
-  BOOST_CHECK(get<1>(t1) > 2.1f && get<1>(t1) < 2.3f);
+  BOOST_TEST(get<1>(t1) > 2.1f && get<1>(t1) < 2.3f);
-  BOOST_CHECK(get<2>(t1) == false);
+  BOOST_TEST(get<2>(t1) == false);
-  BOOST_CHECK(get<3>(t1) == foo(5));
+  BOOST_TEST(get<3>(t1) == foo(5));
 }
 // ----------------------------------------------------------------------------
@ -270,36 +287,40 @@ void
 make_tuple_test()
 {
  tuple<int, char> t1 = make_tuple(5, 'a');
-  BOOST_CHECK(get<0>(t1) == 5);
+  BOOST_TEST(get<0>(t1) == 5);
-  BOOST_CHECK(get<1>(t1) == 'a');
+  BOOST_TEST(get<1>(t1) == 'a');
  tuple<int, std::string> t2;
  t2 = make_tuple((short int)2, std::string("Hi"));
-  BOOST_CHECK(get<0>(t2) == 2);
+  BOOST_TEST(get<0>(t2) == 2);
-  BOOST_CHECK(get<1>(t2) == "Hi");
+  BOOST_TEST(get<1>(t2) == "Hi");
-    A a = A(); B b;
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
    A a; B b;
    const A ca = a;
-    make_tuple(boost::cref(a), b);
+    make_tuple(cref(a), b);
-    make_tuple(boost::ref(a), b);
+    make_tuple(ref(a), b);
-    make_tuple(boost::ref(a), boost::cref(b));
+    make_tuple(ref(a), cref(b));
-    make_tuple(boost::ref(ca));
+    make_tuple(ref(ca));
 #endif
 // the result of make_tuple is assignable:
-   BOOST_CHECK(make_tuple(2, 4, 6) == 
+   BOOST_TEST(make_tuple(2, 4, 6) == 
             (make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
    make_tuple("Donald", "Daisy"); // should work;
 #endif
    //    std::make_pair("Doesn't","Work"); // fails
 // You can store a reference to a function in a tuple
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
    tuple<void(&)()> adf(make_tuple_test);
    dummy(adf); // avoid warning for unused variable
 #endif
 // But make_tuple doesn't work 
 // with function references, since it creates a const qualified function type
@ -336,19 +357,19 @@ tie_test()
  foo c(5);
  tie(a, b, c) = make_tuple(2, 'a', foo(3));
-  BOOST_CHECK(a == 2);
+  BOOST_TEST(a == 2);
-  BOOST_CHECK(b == 'a');
+  BOOST_TEST(b == 'a');
-  BOOST_CHECK(c == foo(3));
+  BOOST_TEST(c == foo(3));
  tie(a, tuples::ignore, c) = make_tuple((short int)5, false, foo(5));
-  BOOST_CHECK(a == 5);
+  BOOST_TEST(a == 5);
-  BOOST_CHECK(b == 'a');
+  BOOST_TEST(b == 'a');
-  BOOST_CHECK(c == foo(5));
+  BOOST_TEST(c == foo(5));
 // testing assignment from std::pair
   int i, j; 
   tie (i, j) = std::make_pair(1, 2);
-   BOOST_CHECK(i == 1 && j == 2);
+   BOOST_TEST(i == 1 && j == 2);
   tuple<int, int, float> ta;
 #ifdef E11
@ -368,13 +389,13 @@ equality_test()
 {
  tuple<int, char> t1(5, 'a');
  tuple<int, char> t2(5, 'a');
-  BOOST_CHECK(t1 == t2);
+  BOOST_TEST(t1 == t2);
  tuple<int, char> t3(5, 'b');
  tuple<int, char> t4(2, 'a');
-  BOOST_CHECK(t1 != t3);
+  BOOST_TEST(t1 != t3);
-  BOOST_CHECK(t1 != t4);
+  BOOST_TEST(t1 != t4);
-  BOOST_CHECK(!(t1 != t2));
+  BOOST_TEST(!(t1 != t2));
 }
@ -388,14 +409,14 @@ ordering_test()
  tuple<int, float> t1(4, 3.3f);
  tuple<short, float> t2(5, 3.3f);
  tuple<long, double> t3(5, 4.4);
-  BOOST_CHECK(t1 < t2);
+  BOOST_TEST(t1 < t2);
-  BOOST_CHECK(t1 <= t2);
+  BOOST_TEST(t1 <= t2);
-  BOOST_CHECK(t2 > t1);
+  BOOST_TEST(t2 > t1);
-  BOOST_CHECK(t2 >= t1);
+  BOOST_TEST(t2 >= t1);
-  BOOST_CHECK(t2 < t3);
+  BOOST_TEST(t2 < t3);
-  BOOST_CHECK(t2 <= t3);
+  BOOST_TEST(t2 <= t3);
-  BOOST_CHECK(t3 > t2);
+  BOOST_TEST(t3 > t2);
-  BOOST_CHECK(t3 >= t2);
+  BOOST_TEST(t3 >= t2);
 }
@ -405,6 +426,7 @@ ordering_test()
 // ----------------------------------------------------------------------------
 void cons_test()
 {
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  using tuples::cons;
  using tuples::null_type;
@ -412,10 +434,11 @@ void cons_test()
  cons<const int, cons<volatile float, null_type> > b(2,a);
  int i = 3;
  cons<int&, cons<const int, cons<volatile float, null_type> > > c(i, b);
-  BOOST_CHECK(make_tuple(3,2,1)==c);
+  BOOST_TEST(make_tuple(3,2,1)==c);
  cons<char, cons<int, cons<float, null_type> > > x;
  dummy(x);
 #endif
 }
 // ----------------------------------------------------------------------------
@ -424,8 +447,8 @@ void cons_test()
 void const_tuple_test()
 {
  const tuple<int, float> t1(5, 3.3f);
-  BOOST_CHECK(get<0>(t1) == 5);
+  BOOST_TEST(get<0>(t1) == 5);
-  BOOST_CHECK(get<1>(t1) == 3.3f);
+  BOOST_TEST(get<1>(t1) == 3.3f);
 }
 // ----------------------------------------------------------------------------