Branch for adding initializer list support (only in the unreleased gcc 4.4 at the moment).

[SVN r48931]
With his kind permission, change Jaakko "Järvi" to "Jarvi"
2008-09-23 19:45:43 +00:00 · 2008-06-28 13:45:21 +00:00 · 2008-02-10 14:56:22 +00:00 · 2007-08-08 19:42:04 +00:00 · 2007-02-06 00:23:26 +00:00 · 2007-01-07 23:50:56 +00:00
13 changed files with 659 additions and 463 deletions
--- a/doc/design_decisions_rationale.html
+++ b/doc/design_decisions_rationale.html
@ -4,7 +4,7 @@

 <body bgcolor="#FFFFFF" text="#000000">

-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
     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="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
     ALT="C++ Boost" width="277" height="86">

  </head>
@ -20,7 +20,9 @@ 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>.
+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. 
+Note that the constness of <code>T</code> does not affect reference type
+elements.
 </p>

 <code><pre>length&lt;T&gt;::value</pre></code>
@ -99,7 +101,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;::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;::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;::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="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
     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;)[5], const char (&amp;)[6]&gt;</code> 
+This creates an object of type <code>tuple&lt;const char (&amp;)[7], 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 D { operator C() const; }
+struct C { C(); C(const B&amp;); };
+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_2>2</a>]
+[<a href="#publ_1">1</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_2>2</a>]
+[<a href="#publ_1">1</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. 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, 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. 
 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,9 +514,9 @@ J&auml;rvi J.: <i>ML-Style Tuple Assignment in Standard C++ - Extending the Mult

 <hr>

-<p>Last modified 2001-09-13</p>
+<p>Last modified 2003-09-07</p>

-<p>&copy; Copyright <a href="../../../people/jaakko_jarvi.htm"> Jaakko J&auml;rvi</a> 2001. 
+<p>&copy; Copyright <a href="http://www.boost.org/people/jaakko_jarvi.htm"> Jaakko J&auml;rvi</a> 2001. 

 Permission to copy, use, modify, sell and distribute this software and its documentation is granted provided this copyright notice appears in all copies. 
 This software and its documentation is provided "as is" without express or implied warranty, and with no claim as to its suitability for any purpose.
--- a/include/boost/tuple/detail/tuple_basic.hpp
+++ b/include/boost/tuple/detail/tuple_basic.hpp
@ -1,38 +1,33 @@
 //  tuple_basic.hpp -----------------------------------------------------

-// Copyright (C) 1999, 2000 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// 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.
+// 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

 // Outside help:
 // This and that, Gary Powell.
-// Fixed return types for get_head/get_tail 
+// 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 Doug Gregor, 
-// William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Davis,
+// Several changes/additions according to suggestions by Douglas Gregor,
+// William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes,
 // David Abrahams.

 // Revision history:
 // 2002 05 01 Hugo Duncan: Fix for Borland after Jaakko's previous changes
-// 2002 04 18 Jaakko: tuple element types can be void or plain function 
+// 2002 04 18 Jaakko: tuple element types can be void or plain function
 //                    types, as long as no object is created.
 //                    Tuple objects can no hold even noncopyable types
-//                    such as arrays.             
+//                    such as arrays.
 // 2001 10 22 John Maddock
 //      Fixes for Borland C++
 // 2001 08 30 David Abrahams
 //      Added default constructor for cons<>.
-// ----------------------------------------------------------------- 
+// -----------------------------------------------------------------

 #ifndef BOOST_TUPLE_BASIC_HPP
 #define BOOST_TUPLE_BASIC_HPP
@ -42,7 +37,9 @@

 #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 {

@ -66,16 +63,16 @@ template <class Then, class Else> struct IF<false, Then, Else> {
 } // end detail

 // - cons forward declaration -----------------------------------------------
-template <class HT, class TT> struct cons; 
+template <class HT, class TT> struct cons;


 // - tuple forward declaration -----------------------------------------------
 template <
-  class T0 = null_type, class T1 = null_type, class T2 = null_type, 
-  class T3 = null_type, class T4 = null_type, class T5 = null_type, 
-  class T6 = null_type, class T7 = null_type, class T8 = null_type, 
+  class T0 = null_type, class T1 = null_type, class T2 = null_type,
+  class T3 = null_type, class T4 = null_type, class T5 = null_type,
+  class T6 = null_type, class T7 = null_type, class T8 = null_type,
  class T9 = null_type>
-class tuple; 
+class tuple;

 // tuple_length forward declaration
 template<class T> struct length;
@ -84,18 +81,7 @@ 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 
+// -- generate error template, referencing to non-existing members of this
 // template is used to produce compilation errors intentionally
 template<class T>
 class generate_error;
@ -108,23 +94,33 @@ struct get_class {
  template<class RET, class HT, class TT >
  inline static RET get(const cons<HT, TT>& t)
  {
-    return get_class<N-1>::template get<RET>(t.tail);
+#if BOOST_WORKAROUND(__IBMCPP__,==600)
+    // 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)
  {
-    return get_class<N-1>::template get<RET>(t.tail);
+#if BOOST_WORKAROUND(__IBMCPP__,==600)
+    return get_class<N-1>::get<RET>(t.tail);
+#else
+    return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
+#endif
  }
 };

 template<>
 struct get_class<0> {
-  template<class RET, class HT, class TT> 
+  template<class RET, class HT, class TT>
  inline static RET get(const cons<HT, TT>& t)
  {
    return t.head;
  }
-  template<class RET, class HT, class TT> 
+  template<class RET, class HT, class TT>
  inline static RET get(cons<HT, TT>& t)
  {
    return t.head;
@ -135,10 +131,12 @@ struct get_class<0> {


 // -cons type accessors ----------------------------------------
-// typename tuples::element<N,T>::type gets the type of the 
+// typename tuples::element<N,T>::type gets the type of the
 // Nth element ot T, first element is at index 0
 // -------------------------------------------------------

+#ifndef BOOST_NO_CV_SPECIALIZATIONS
+
 template<int N, class T>
 struct element
 {
@ -153,6 +151,76 @@ 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)

@ -179,8 +247,8 @@ template <class T> struct access_traits<T&> {

  typedef T& const_type;
  typedef T& non_const_type;
-   
-  typedef T& parameter_type;   
+
+  typedef T& parameter_type;
 };

 // get function for non-const cons-lists, returns a reference to the element
@ -189,13 +257,19 @@ 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_TUPLE_DUMMY_PARM) { 
-  return detail::get_class<N>::template 
+get(cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+#if BOOST_WORKAROUND(__IBMCPP__,==600 )
+  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>(c); 
-} 
+           >::non_const_type,
+           HT,TT
+         >(c);
+}

 // get function for const cons-lists, returns a const reference to
 // the element. If the element is a reference, returns the reference
@ -204,13 +278,19 @@ 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_TUPLE_DUMMY_PARM) { 
-  return detail::get_class<N>::template 
+get(const cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+#if BOOST_WORKAROUND(__IBMCPP__,==600)
+  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>(c);
-} 
+           >::const_type,
+           HT,TT
+         >(c);
+}

 // -- the cons template  --------------------------------------------------
 namespace detail {
@ -231,7 +311,7 @@ template <class T> struct wrap_non_storeable_type {
  >::RET type;
 };
 template <> struct wrap_non_storeable_type<void> {
-  typedef non_storeable_type<void> type; 
+  typedef non_storeable_type<void> type;
 };

 } // detail
@ -242,49 +322,49 @@ struct cons {
  typedef HT head_type;
  typedef TT tail_type;

-  typedef typename 
+  typedef typename
    detail::wrap_non_storeable_type<head_type>::type stored_head_type;

  stored_head_type head;
  tail_type tail;

-  typename access_traits<stored_head_type>::non_const_type 
+  typename access_traits<stored_head_type>::non_const_type
  get_head() { return head; }

-  typename access_traits<tail_type>::non_const_type 
-  get_tail() { return tail; }  
+  typename access_traits<tail_type>::non_const_type
+  get_tail() { return tail; }

-  typename access_traits<stored_head_type>::const_type 
+  typename access_traits<stored_head_type>::const_type
  get_head() const { return head; }
-  
-  typename access_traits<tail_type>::const_type 
-  get_tail() const { return tail; }  
+
+  typename access_traits<tail_type>::const_type
+  get_tail() const { return tail; }

  cons() : head(), tail() {}
  //  cons() : head(detail::default_arg<HT>::f()), tail() {}

-  // the argument for head is not strictly needed, but it prevents 
-  // array type elements. This is good, since array type elements 
-  // cannot be supported properly in any case (no assignment, 
+  // the argument for head is not strictly needed, but it prevents
+  // array type elements. This is good, since array type elements
+  // cannot be supported properly in any case (no assignment,
  // copy works only if the tails are exactly the same type, ...)
-  
+
  cons(typename access_traits<stored_head_type>::parameter_type h,
       const tail_type& t)
-    : head (h), tail(t) {}  
+    : head (h), tail(t) {}

-  template <class T1, class T2, class T3, class T4, class T5, 
+  template <class T1, class T2, class T3, class T4, class T5,
            class T6, class T7, class T8, class T9, class T10>
-  cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, 
-        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 ) 
-    : head (t1), 
+  cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5,
+        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
+    : head (t1),
      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
      {}

-  template <class T2, class T3, class T4, class T5, 
+  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, 
-        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 ) 
-    : head (), 
+  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())
      {}

@ -293,18 +373,18 @@ struct cons {
  cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}

  template <class HT2, class TT2>
-  cons& operator=( const cons<HT2, TT2>& u ) { 
-    head=u.head; tail=u.tail; return *this; 
+  cons& operator=( const cons<HT2, TT2>& u ) {
+    head=u.head; tail=u.tail; return *this;
  }

-  // must define assignment operator explicitly, implicit version is 
+  // must define assignment operator explicitly, implicit version is
  // illformed if HT is a reference (12.8. (12))
-  cons& operator=(const cons& u) { 
-    head = u.head; tail = u.tail;  return *this; 
+  cons& operator=(const cons& u) {
+    head = u.head; tail = u.tail;  return *this;
  }

  template <class T1, class T2>
-  cons& operator=( const std::pair<T1, T2>& u ) { 
+  cons& operator=( const std::pair<T1, T2>& u ) {
    BOOST_STATIC_ASSERT(length<cons>::value == 2); // check length = 2
    head = u.first; tail.head = u.second; return *this;
  }
@ -332,64 +412,65 @@ struct cons<HT, null_type> {

  typedef HT head_type;
  typedef null_type tail_type;
+  typedef cons<HT, null_type> self_type;

-  typedef typename 
+  typedef typename
    detail::wrap_non_storeable_type<head_type>::type stored_head_type;
  stored_head_type head;
- 
-  typename access_traits<stored_head_type>::non_const_type 
-  get_head() { return head; }
-  
-  null_type get_tail() { return null_type(); }  

-  typename access_traits<stored_head_type>::const_type 
+  typename access_traits<stored_head_type>::non_const_type
+  get_head() { return head; }
+
+  null_type get_tail() { return null_type(); }
+
+  typename access_traits<stored_head_type>::const_type
  get_head() const { return head; }
-  
-  const null_type get_tail() const { return null_type(); }  
+
+  const null_type get_tail() const { return null_type(); }

  //  cons() : head(detail::default_arg<HT>::f()) {}
  cons() : head() {}

  cons(typename access_traits<stored_head_type>::parameter_type h,
       const null_type& = null_type())
-    : head (h) {}  
+    : head (h) {}

  template<class T1>
-  cons(T1& t1, const null_type&, const null_type&, const null_type&, 
-       const null_type&, const null_type&, const null_type&, 
+  cons(T1& 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&)
  : head (t1) {}

-  cons(const null_type& t1, 
-       const null_type&, const null_type&, const null_type&, 
-       const null_type&, const null_type&, const null_type&, 
+  cons(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&, const null_type&)
  : head () {}

  template <class HT2>
  cons( const cons<HT2, null_type>& u ) : head(u.head) {}
-  
+
  template <class HT2>
-  cons& operator=(const cons<HT2, null_type>& u ) 
+  cons& operator=(const cons<HT2, null_type>& u )
  { head = u.head; return *this; }

-  // must define assignment operator explicitely, implicit version 
+  // must define assignment operator explicitely, implicit version
  // is illformed if HT is a reference
  cons& operator=(const cons& u) { head = u.head; return *this; }

  template <int N>
  typename access_traits<
-             typename element<N, cons>::type
+             typename element<N, self_type>::type
            >::non_const_type
-  get(BOOST_TUPLE_SINGLE_DUMMY_PARM) {
+  get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
    return boost::tuples::get<N>(*this);
  }

  template <int N>
  typename access_traits<
-             typename element<N, cons>::type
+             typename element<N, self_type>::type
           >::const_type
-  get(BOOST_TUPLE_SINGLE_DUMMY_PARM) const {
+  get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) const {
    return boost::tuples::get<N>(*this);
  }

@ -416,12 +497,12 @@ struct length<null_type> {
 namespace detail {

 // Tuple to cons mapper --------------------------------------------------
-template <class T0, class T1, class T2, class T3, class T4, 
+template <class T0, class T1, class T2, class T3, class T4,
          class T5, class T6, class T7, class T8, class T9>
 struct map_tuple_to_cons
 {
-  typedef cons<T0, 
-               typename map_tuple_to_cons<T1, T2, T3, T4, T5, 
+  typedef cons<T0,
+               typename map_tuple_to_cons<T1, T2, T3, T4, T5,
                                          T6, T7, T8, T9, null_type>::type
              > type;
 };
@ -437,46 +518,46 @@ struct map_tuple_to_cons<null_type, null_type, null_type, null_type, null_type,

 // -------------------------------------------------------------------
 // -- tuple ------------------------------------------------------
-template <class T0, class T1, class T2, class T3, class T4, 
+template <class T0, class T1, class T2, class T3, class T4,
          class T5, class T6, class T7, class T8, class T9>

-class tuple : 
-  public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type   
+class tuple :
+  public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
 {
 public:
-  typedef typename 
+  typedef typename
    detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited;
  typedef typename inherited::head_type head_type;
-  typedef typename inherited::tail_type tail_type;  
+  typedef typename inherited::tail_type tail_type;


-// access_traits<T>::parameter_type takes non-reference types as const T& 
+// access_traits<T>::parameter_type takes non-reference types as const T&
  tuple() {}
-  
+
  tuple(typename access_traits<T0>::parameter_type t0)
-    : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(), 
-                detail::cnull(), detail::cnull(), detail::cnull(), 
+    : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1)
-    : inherited(t0, t1, detail::cnull(), detail::cnull(), 
-                detail::cnull(), detail::cnull(), detail::cnull(), 
+    : inherited(t0, t1, detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2)
-    : inherited(t0, t1, t2, detail::cnull(), detail::cnull(), 
-                detail::cnull(), detail::cnull(), detail::cnull(), 
+    : inherited(t0, t1, t2, detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3)
-    : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(), 
-                detail::cnull(), detail::cnull(), detail::cnull(), 
+    : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
@ -484,7 +565,7 @@ public:
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4)
-    : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(), 
+    : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
@ -493,7 +574,7 @@ public:
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4,
        typename access_traits<T5>::parameter_type t5)
-    : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(), 
+    : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
@ -503,7 +584,7 @@ public:
        typename access_traits<T4>::parameter_type t4,
        typename access_traits<T5>::parameter_type t5,
        typename access_traits<T6>::parameter_type t6)
-    : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(), 
+    : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(),
                detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
@ -514,7 +595,7 @@ public:
        typename access_traits<T5>::parameter_type t5,
        typename access_traits<T6>::parameter_type t6,
        typename access_traits<T7>::parameter_type t7)
-    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(), 
+    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(),
                detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
@ -545,16 +626,16 @@ public:
  tuple(const cons<U1, U2>& p) : inherited(p) {}

  template <class U1, class U2>
-  tuple& operator=(const cons<U1, U2>& k) { 
-    inherited::operator=(k); 
+  tuple& operator=(const cons<U1, U2>& k) {
+    inherited::operator=(k);
    return *this;
  }

  template <class U1, class U2>
-  tuple& operator=(const std::pair<U1, U2>& k) { 
+  tuple& operator=(const std::pair<U1, U2>& k) {
    BOOST_STATIC_ASSERT(length<tuple>::value == 2);// check_length = 2
    this->head = k.first;
-    this->tail.head = k.second; 
+    this->tail.head = k.second;
    return *this;
  }

@ -562,8 +643,8 @@ public:

 // The empty tuple
 template <>
-class tuple<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>  : 
-  public null_type 
+class tuple<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>  :
+  public null_type
 {
 public:
  typedef null_type inherited;
@ -574,19 +655,17 @@ public:
 namespace detail {

 struct swallow_assign {
-      
+
  template<typename T>
-  swallow_assign& operator=(const T&) {
+  swallow_assign const& operator=(const T&) const {
    return *this;
  }
 };

 } // namespace detail

-// "ignore" allows tuple positions to be ignored when using "tie". 
-namespace {
- detail::swallow_assign ignore;
-}
+// "ignore" allows tuple positions to be ignored when using "tie".
+detail::swallow_assign const ignore = detail::swallow_assign();

 // ---------------------------------------------------------------------------
 // The call_traits for make_tuple
@ -598,7 +677,7 @@ namespace {
 // from template<class T> foo(T& t) : make_tuple_traits<T>::type

 // Conversions:
-// T -> T, 
+// T -> T,
 // references -> compile_time_error
 // reference_wrapper<T> -> T&
 // const reference_wrapper<T> -> T&
@ -607,19 +686,19 @@ namespace {

 template<class T>
 struct make_tuple_traits {
-  typedef T type; 
+  typedef T type;

  // commented away, see below  (JJ)
-  //  typedef typename IF<                 
+  //  typedef typename IF<
  //  boost::is_function<T>::value,
  //  T&,
  //  T>::RET type;

 };
- 
-// The is_function test was there originally for plain function types, 
+
+// The is_function test was there originally for plain function types,
 // which can't be stored as such (we must either store them as references or
-// pointers). Such a type could be formed if make_tuple was called with a 
+// pointers). Such a type could be formed if make_tuple was called with a
 // reference to a function.
 // But this would mean that a const qualified function type was formed in
 // the make_tuple function and hence make_tuple can't take a function
@ -634,17 +713,17 @@ struct make_tuple_traits<T&> {
  typedef typename
     detail::generate_error<T&>::
       do_not_use_with_reference_type error;
-}; 
+};

 // Arrays can't be stored as plain types; convert them to references.
 // All arrays are converted to const. This is because make_tuple takes its
-// parameters as const T& and thus the knowledge of the potential 
+// parameters as const T& and thus the knowledge of the potential
 // non-constness of actual argument is lost.
 template<class T, int n>  struct make_tuple_traits <T[n]> {
  typedef const T (&type)[n];
 };

-template<class T, int n> 
+template<class T, int n>
 struct make_tuple_traits<const T[n]> {
  typedef const T (&type)[n];
 };
@ -653,17 +732,17 @@ template<class T, int n>  struct make_tuple_traits<volatile T[n]> {
  typedef const volatile T (&type)[n];
 };

-template<class T, int n> 
+template<class T, int n>
 struct make_tuple_traits<const volatile T[n]> {
  typedef const volatile T (&type)[n];
 };

-template<class T> 
+template<class T>
 struct make_tuple_traits<reference_wrapper<T> >{
  typedef T& type;
 };

-template<class T> 
+template<class T>
 struct make_tuple_traits<const reference_wrapper<T> >{
  typedef T& type;
 };
@ -676,20 +755,20 @@ namespace detail {
 // a helper traits to make the make_tuple functions shorter (Vesa Karvonen's
 // suggestion)
 template <
-  class T0 = null_type, class T1 = null_type, class T2 = null_type, 
-  class T3 = null_type, class T4 = null_type, class T5 = null_type, 
-  class T6 = null_type, class T7 = null_type, class T8 = null_type, 
+  class T0 = null_type, class T1 = null_type, class T2 = null_type,
+  class T3 = null_type, class T4 = null_type, class T5 = null_type,
+  class T6 = null_type, class T7 = null_type, class T8 = null_type,
  class T9 = null_type
 >
 struct make_tuple_mapper {
  typedef
-    tuple<typename make_tuple_traits<T0>::type, 
-          typename make_tuple_traits<T1>::type, 
-          typename make_tuple_traits<T2>::type, 
-          typename make_tuple_traits<T3>::type, 
-          typename make_tuple_traits<T4>::type, 
-          typename make_tuple_traits<T5>::type, 
-          typename make_tuple_traits<T6>::type, 
+    tuple<typename make_tuple_traits<T0>::type,
+          typename make_tuple_traits<T1>::type,
+          typename make_tuple_traits<T2>::type,
+          typename make_tuple_traits<T3>::type,
+          typename make_tuple_traits<T4>::type,
+          typename make_tuple_traits<T5>::type,
+          typename make_tuple_traits<T6>::type,
          typename make_tuple_traits<T7>::type,
          typename make_tuple_traits<T8>::type,
          typename make_tuple_traits<T9>::type> type;
@ -699,7 +778,7 @@ struct make_tuple_mapper {

 // -make_tuple function templates -----------------------------------
 inline tuple<> make_tuple() {
-  return tuple<>(); 
+  return tuple<>();
 }

 template<class T0>
@ -735,7 +814,7 @@ inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type
 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4) {
  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type t;
-  return t(t0, t1, t2, t3, t4); 
+  return t(t0, t1, t2, t3, t4);
 }

 template<class T0, class T1, class T2, class T3, class T4, class T5>
@ -743,7 +822,7 @@ inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4, const T5& t5) {
  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type t;
-  return t(t0, t1, t2, t3, t4, t5); 
+  return t(t0, t1, t2, t3, t4, t5);
 }

 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
@ -762,7 +841,7 @@ make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4, const T5& t5, const T6& t6, const T7& t7) {
  typedef typename detail::make_tuple_mapper
           <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
-  return t(t0, t1, t2, t3, t4, t5, t6, t7); 
+  return t(t0, t1, t2, t3, t4, t5, t6, t7);
 }

 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
@ -774,7 +853,7 @@ make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T8& t8) {
  typedef typename detail::make_tuple_mapper
           <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
-  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8); 
+  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
 }

 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
@ -786,7 +865,7 @@ make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T8& t8, const T9& t9) {
  typedef typename detail::make_tuple_mapper
           <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
-  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9); 
+  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
 }


@ -813,54 +892,52 @@ inline tuple<T1&, T2&, T3&, T4&> tie(T1& t1, T2& t2, T3& t3, T4& t4) {
 }

 template<class T1, class T2, class T3, class T4, class T5>
-inline tuple<T1&, T2&, T3&, T4&, T5&> 
+inline tuple<T1&, T2&, T3&, T4&, T5&>
 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) {
  return tuple<T1&, T2&, T3&, T4&, T5&> (t1, t2, t3, t4, t5);
 }

 template<class T1, class T2, class T3, class T4, class T5, class T6>
-inline tuple<T1&, T2&, T3&, T4&, T5&, T6&> 
+inline tuple<T1&, T2&, T3&, T4&, T5&, T6&>
 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) {
  return tuple<T1&, T2&, T3&, T4&, T5&, T6&> (t1, t2, t3, t4, t5, t6);
 }

 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> 
+inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&>
 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) {
  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> (t1, t2, t3, t4, t5, t6, t7);
 }

-template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, 
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
         class T8>
-inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&> 
+inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) {
-  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&> 
+  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
           (t1, t2, t3, t4, t5, t6, t7, t8);
 }

-template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, 
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
         class T8, class T9>
-inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&> 
-tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, 
+inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
+tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
           T9& t9) {
-  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&> 
+  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
            (t1, t2, t3, t4, t5, t6, t7, t8, t9);
 }

-template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, 
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
         class T8, class T9, class T10>
-inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&> 
-tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, 
+inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
+tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
           T9& t9, T10& t10) {
-  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&> 
+  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
           (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
 }

 } // 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,32 +1,27 @@
 // - tuple_basic_no_partial_spec.hpp -----------------------------------------

-// Copyright (C) 1999, 2000 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2001 Doug Gregor (gregod@rpi.edu)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2001 Douglas Gregor (gregod@rpi.edu)
 // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
 //
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// 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.
+// 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 or http://lambda.cs.utu.fi 
+// For more information, see http://www.boost.org or http://lambda.cs.utu.fi

-// Revision History 
+// Revision History
 //  14 02 01    Remove extra ';'. Also, fixed 10-parameter to make_tuple. (DG)
 //  10 02 01    Fixed "null_type" constructors.
 //              Implemented comparison operators globally.
 //              Hide element_type_ref and element_type_const_ref.
 //              (DG).
-//  09 02 01    Extended to tuples of length 10. Changed comparison for 
+//  09 02 01    Extended to tuples of length 10. Changed comparison for
 //              operator<()
 //              to the same used by std::pair<>, added cnull_type() (GP)
 //  03 02 01    Initial Version from original tuple.hpp code by JJ. (DG)

-// ----------------------------------------------------------------- 
+// -----------------------------------------------------------------

 #ifndef BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
 #define BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
@ -44,20 +39,20 @@ namespace boost {
 namespace tuples {

    // null_type denotes the end of a list built with "cons"
-    struct null_type 
+    struct null_type
    {
      null_type() {}
      null_type(const null_type&, const null_type&) {}
    };
-     
+
    // a helper function to provide a const null_type type temporary
    inline const null_type cnull_type() { return null_type(); }

 // forward declaration of tuple
    template<
-      typename T1 = null_type, 
-      typename T2 = null_type, 
-      typename T3 = null_type, 
+      typename T1 = null_type,
+      typename T2 = null_type,
+      typename T3 = null_type,
      typename T4 = null_type,
      typename T5 = null_type,
      typename T6 = null_type,
@ -68,6 +63,10 @@ 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
@ -92,57 +91,125 @@ namespace tuples {
      struct swallow_assign
      {
        template<typename T>
-        swallow_assign& operator=(const T&)
+        swallow_assign const& operator=(const T&) const
        {
          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 = null_type>
+   template<typename Head, typename Tail>
   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;

-     typename boost::add_reference<head_type>::type get_head() { return head; }
-     typename boost::add_reference<tail_type>::type get_tail() { return tail; }  
+     head_ref get_head() { return head; }
+     tail_ref get_tail() { return tail; }
+
+     head_cref get_head() const { return head; }
+     tail_cref get_tail() const { return tail; }
+
+     cons() : head(), tail() {}

-     typename boost::add_reference<const head_type>::type get_head() const { return head; }
-     typename boost::add_reference<const tail_type>::type get_tail() const { return tail; }
-  
 #if defined BOOST_MSVC
      template<typename Tail>
-      explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
+      cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
                    const Tail& t) : head(h), tail(t.head, t.tail)
      {
      }

-      explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
+      cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
                    const null_type& t) : head(h), tail(t)
      {
      }

 #else
      template<typename T>
-      explicit cons(const head_type& h, const T& t) : 
+      explicit cons(head_cref h, const T& t) :
        head(h), tail(t.head, t.tail)
      {
      }

-      explicit cons(const head_type& h = head_type(),
-                    const tail_type& t = tail_type()) :
+      explicit cons(head_cref h = head_type(),
+                    tail_cref 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)
@ -152,13 +219,13 @@ namespace tuples {
        return *this;
      }
    };
-  
+
    namespace detail {

      // Determines if the parameter is null_type
      template<typename T> struct is_null_type { enum { RET = 0 }; };
      template<> struct is_null_type<null_type> { enum { RET = 1 }; };
-      
+
      /* Build a cons structure from the given Head and Tail. If both are null_type,
      return null_type. */
      template<typename Head, typename Tail>
@ -178,15 +245,15 @@ namespace tuples {

      // Map the N elements of a tuple into a cons list
      template<
-        typename T1, 
-        typename T2 = null_type, 
-        typename T3 = null_type, 
-        typename T4 = null_type, 
-        typename T5 = null_type, 
-        typename T6 = null_type, 
-        typename T7 = null_type, 
-        typename T8 = null_type, 
-        typename T9 = null_type, 
+        typename T1,
+        typename T2 = null_type,
+        typename T3 = null_type,
+        typename T4 = null_type,
+        typename T5 = null_type,
+        typename T6 = null_type,
+        typename T7 = null_type,
+        typename T8 = null_type,
+        typename T9 = null_type,
        typename T10 = null_type
      >
      struct map_tuple_to_cons
@ -331,7 +398,7 @@ namespace tuples {
    {
      BOOST_STATIC_CONSTANT(int, value = 1 + length<typename Tuple::tail_type>::value);
    };
-    
+
    template<> struct length<tuple<> > {
      BOOST_STATIC_CONSTANT(int, value = 0);
    };
@ -389,9 +456,9 @@ namespace tuples {

    // tuple class
    template<
-      typename T1, 
-      typename T2, 
-      typename T3, 
+      typename T1,
+      typename T2,
+      typename T3,
      typename T4,
      typename T5,
      typename T6,
@ -400,7 +467,7 @@ namespace tuples {
      typename T9,
      typename T10
    >
-    class tuple : 
+    class tuple :
      public detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
    {
    private:
@ -416,26 +483,45 @@ 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;

-      explicit tuple(const T1& t1 = T1(), 
-                     const T2& t2 = T2(),
-                     const T3& t3 = T3(),
-                     const T4& t4 = T4(),
-                     const T5& t5 = T5(),
-                     const T6& t6 = T6(),
-                     const T7& t7 = T7(),
-                     const T8& t8 = T8(),
-                     const T9& t9 = T9(),
-                     const T10& t10 = T10()) :
+      tuple() : cons1(T1(), cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
+        {}
+
+      tuple(
+          t1_cref t1,
+          t2_cref t2,
+          t3_cref t3 = T3(),
+          t4_cref t4 = T4(),
+          t5_cref t5 = T5(),
+          t6_cref t6 = T6(),
+          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>
-      explicit tuple(const cons<Head, Tail>& other) : 
+      tuple(const cons<Head, Tail>& other) :
        cons1(other.head, other.tail)
      {
      }
@ -531,7 +617,7 @@ namespace tuples {
    {
      return tuple<T1, T2, T3, T4, T5, T6>(t1, t2, t3, t4, t5, t6);
    }
-  
+
    // Make a tuple
    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
    inline
@ -580,7 +666,7 @@ namespace tuples {
    // Tie variables into a tuple
    template<typename T1, typename T2>
    inline
-    tuple<detail::assign_to_pointee<T1>, 
+    tuple<detail::assign_to_pointee<T1>,
      detail::assign_to_pointee<T2> >
    tie(T1& t1, T2& t2)
    {
@ -591,8 +677,8 @@ namespace tuples {
    // Tie variables into a tuple
    template<typename T1, typename T2, typename T3>
    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
+    tuple<detail::assign_to_pointee<T1>,
+      detail::assign_to_pointee<T2>,
      detail::assign_to_pointee<T3> >
    tie(T1& t1, T2& t2, T3& t3)
    {
@ -604,9 +690,9 @@ namespace tuples {
    // Tie variables into a tuple
    template<typename T1, typename T2, typename T3, typename T4>
    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
+    tuple<detail::assign_to_pointee<T1>,
+      detail::assign_to_pointee<T2>,
+      detail::assign_to_pointee<T3>,
      detail::assign_to_pointee<T4> >
    tie(T1& t1, T2& t2, T3& t3, T4& t4)
    {
@ -619,10 +705,10 @@ namespace tuples {
    // Tie variables into a tuple
    template<typename T1, typename T2, typename T3, typename T4, typename T5>
    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4>, 
+    tuple<detail::assign_to_pointee<T1>,
+      detail::assign_to_pointee<T2>,
+      detail::assign_to_pointee<T3>,
+      detail::assign_to_pointee<T4>,
      detail::assign_to_pointee<T5> >
    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5)
    {
@ -636,11 +722,11 @@ namespace tuples {
    // Tie variables into a tuple
    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4>, 
-      detail::assign_to_pointee<T5>, 
+    tuple<detail::assign_to_pointee<T1>,
+      detail::assign_to_pointee<T2>,
+      detail::assign_to_pointee<T3>,
+      detail::assign_to_pointee<T4>,
+      detail::assign_to_pointee<T5>,
      detail::assign_to_pointee<T6> >
    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6)
    {
@ -655,12 +741,12 @@ namespace tuples {
    // Tie variables into a tuple
    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4>, 
-      detail::assign_to_pointee<T5>, 
-      detail::assign_to_pointee<T6>, 
+    tuple<detail::assign_to_pointee<T1>,
+      detail::assign_to_pointee<T2>,
+      detail::assign_to_pointee<T3>,
+      detail::assign_to_pointee<T4>,
+      detail::assign_to_pointee<T5>,
+      detail::assign_to_pointee<T6>,
      detail::assign_to_pointee<T7> >
    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7)
    {
@ -676,13 +762,13 @@ namespace tuples {
    // Tie variables into a tuple
    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4>, 
-      detail::assign_to_pointee<T5>, 
-      detail::assign_to_pointee<T6>, 
-      detail::assign_to_pointee<T7>, 
+    tuple<detail::assign_to_pointee<T1>,
+      detail::assign_to_pointee<T2>,
+      detail::assign_to_pointee<T3>,
+      detail::assign_to_pointee<T4>,
+      detail::assign_to_pointee<T5>,
+      detail::assign_to_pointee<T6>,
+      detail::assign_to_pointee<T7>,
      detail::assign_to_pointee<T8> >
    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8)
    {
@ -699,14 +785,14 @@ namespace tuples {
    // Tie variables into a tuple
    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4>, 
-      detail::assign_to_pointee<T5>, 
-      detail::assign_to_pointee<T6>, 
-      detail::assign_to_pointee<T7>, 
-      detail::assign_to_pointee<T8>, 
+    tuple<detail::assign_to_pointee<T1>,
+      detail::assign_to_pointee<T2>,
+      detail::assign_to_pointee<T3>,
+      detail::assign_to_pointee<T4>,
+      detail::assign_to_pointee<T5>,
+      detail::assign_to_pointee<T6>,
+      detail::assign_to_pointee<T7>,
+      detail::assign_to_pointee<T8>,
      detail::assign_to_pointee<T9> >
    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9)
    {
@ -723,15 +809,15 @@ namespace tuples {
    // Tie variables into a tuple
    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4>, 
-      detail::assign_to_pointee<T5>, 
-      detail::assign_to_pointee<T6>, 
-      detail::assign_to_pointee<T7>, 
-      detail::assign_to_pointee<T8>, 
-      detail::assign_to_pointee<T9>, 
+    tuple<detail::assign_to_pointee<T1>,
+      detail::assign_to_pointee<T2>,
+      detail::assign_to_pointee<T3>,
+      detail::assign_to_pointee<T4>,
+      detail::assign_to_pointee<T5>,
+      detail::assign_to_pointee<T6>,
+      detail::assign_to_pointee<T7>,
+      detail::assign_to_pointee<T8>,
+      detail::assign_to_pointee<T9>,
      detail::assign_to_pointee<T10> >
    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9, T10 &t10)
    {
@ -746,10 +832,9 @@ namespace tuples {
                        detail::assign_to_pointee<T9>(&t9),
                        detail::assign_to_pointee<T10>(&t10));
    }
-    // "ignore" allows tuple positions to be ignored when using "tie". 
-    namespace {
-      detail::swallow_assign ignore;
-    }
+    // "ignore" allows tuple positions to be ignored when using "tie".
+
+detail::swallow_assign const ignore = detail::swallow_assign();

 } // namespace tuples
 } // namespace boost
--- a/include/boost/tuple/tuple.hpp
+++ b/include/boost/tuple/tuple.hpp
@ -1,15 +1,10 @@
 //  tuple.hpp - Boost Tuple Library --------------------------------------

-// Copyright (C) 1999, 2000 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// 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.
+// 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

@ -18,6 +13,13 @@
 #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
@ -1,16 +1,11 @@
 // tuple_comparison.hpp -----------------------------------------------------
 //  
-// Copyright (C) 2001 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
 //
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// 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.
+// 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
 // 
--- a/include/boost/tuple/tuple_io.hpp
+++ b/include/boost/tuple/tuple_io.hpp
@ -1,16 +1,11 @@
 // tuple_io.hpp --------------------------------------------------------------

-// Copyright (C) 2001 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //               2001 Gary Powell (gary.powell@sierra.com)
 //
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// 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.
+// 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 

 // ----------------------------------------------------------------------------
@ -36,6 +31,23 @@

 #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 {

@ -69,9 +81,9 @@ public:
     // parentheses and space are the default manipulators
     if (!c) {
       switch(m) {
-         case open : c = '('; break;
-         case close : c = ')'; break;
-         case delimiter : c = ' '; break;
+         case detail::format_info::open : c = '('; break;
+         case detail::format_info::close : c = ')'; break;
+         case detail::format_info::delimiter : c = ' '; break;
       }
     }
     return c;
@ -92,9 +104,9 @@ public:
     // parentheses and space are the default manipulators
     if (!c) {
       switch(m) {
-         case open :  c = i.widen('('); break;
-         case close : c = i.widen(')'); break;
-         case delimiter : c = i.widen(' '); break;
+         case detail::format_info::open :  c = i.widen('('); break;
+         case detail::format_info::close : c = i.widen(')'); break;
+         case detail::format_info::delimiter : c = i.widen(' '); break;
       }
     }
     return c;
@ -328,12 +340,16 @@ extract_and_check_delimiter(
 {
  const char d = format_info::get_manipulator(is, del);

-  const bool is_delimiter = (!isspace(d) );      
+#if defined (BOOST_NO_STD_LOCALE)
+  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 (c!=d) {
+    if (is.good() && c!=d) {
      is.setstate(std::ios::failbit);
    } 
  }
@ -415,12 +431,19 @@ extract_and_check_delimiter(
 {
  const CharType d = format_info::get_manipulator(is, del);

-  const bool is_delimiter = (!isspace(d) );      
+#if defined (BOOST_NO_STD_LOCALE)
+  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 (c!=d) { 
+    if (is.good() && c!=d) { 
      is.setstate(std::ios::failbit);
    }
  }
--- a/index.html
+++ b/index.html
@ -0,0 +1,13 @@
+<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
@ -0,0 +1,8 @@
+
+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,3 +1,12 @@
+// Copyright (C) 1999, 2000 Jaakko Jarvi (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
@ -89,12 +98,11 @@ 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
@ -105,8 +113,6 @@ void foo4()
 #ifdef E10
  dummy(get<5>(ct)); // illegal index
 #endif
-
-#endif
 }

 // testing copy and assignment with implicit conversions between elements
@ -119,9 +125,10 @@ 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,3 +1,11 @@
+// Copyright (C) 1999, 2000 Jaakko Jarvi (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
@ -19,8 +27,6 @@
 #include <sstream>
 #endif

-#include "boost/config.hpp"
-
 using namespace std;
 using namespace boost;

@ -33,7 +39,8 @@ 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;
@ -45,7 +52,7 @@ int test_main(int argc, char * argv[] ) {
  os1 << set_close(']');
  os1 << set_delimiter(',');
  os1 << make_tuple(1, 2, 3);
-  BOOST_TEST (os1.str() == std::string("[1,2,3]") );
+  BOOST_CHECK (os1.str() == std::string("[1,2,3]") );

  {
  useThisOStringStream os2;
@ -55,13 +62,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_TEST (os2.str() == std::string("(TUPU:HUPU:LUPU:4.5)") );
+  BOOST_CHECK (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_TEST (os1.str() == std::string("[1,2,3][1,2,3]") );
+  BOOST_CHECK (os1.str() == std::string("[1,2,3][1,2,3]") );

  ofstream tmp("temp.tmp");

@ -79,13 +86,13 @@ int test_main(int argc, char * argv[] ) {

 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  tmp3 >> j; 
-  BOOST_TEST (tmp3.good() ); 
+  BOOST_CHECK (tmp3.good() ); 
 #endif
   
  tmp3 >> set_delimiter(':');
  tuple<int, int, int> i;
  tmp3 >> i; 
-  BOOST_TEST (tmp3.good() ); 
+  BOOST_CHECK (tmp3.good() ); 
   
  tmp3.close(); 

@ -94,8 +101,8 @@ int test_main(int argc, char * argv[] ) {
  useThisIStringStream is("(100 200 300)"); 
   
  tuple<int, int, int> ti; 
-  BOOST_TEST(is >> ti);
-  BOOST_TEST(ti == make_tuple(100, 200, 300));
+  BOOST_CHECK(bool(is >> ti));
+  BOOST_CHECK(ti == make_tuple(100, 200, 300));
   

  // Note that strings are problematic:
--- a/test/tuple_test_bench.cpp
+++ b/test/tuple_test_bench.cpp
@ -1,3 +1,11 @@
+// Copyright (C) 1999, 2000 Jaakko Jarvi (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
@ -7,6 +15,9 @@

 #include "boost/tuple/tuple_comparison.hpp"

+#include "boost/type_traits/is_const.hpp"
+
+#include "boost/ref.hpp"
 #include <string>
 #include <utility>

@ -66,7 +77,6 @@ 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;
@ -77,22 +87,16 @@ 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()
@ -103,32 +107,32 @@ construction_test()
  // MSVC 6.0 just cannot find get without the namespace qualifier

  tuple<int> t1;
-  BOOST_TEST(get<0>(t1) == int());
+  BOOST_CHECK(get<0>(t1) == int());

  tuple<float> t2(5.5f);
-  BOOST_TEST(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f);
+  BOOST_CHECK(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f);

  tuple<foo> t3(foo(12));
-  BOOST_TEST(get<0>(t3) == foo(12));
+  BOOST_CHECK(get<0>(t3) == foo(12));

  tuple<double> t4(t2);
-  BOOST_TEST(get<0>(t4) > 5.4 && get<0>(t4) < 5.6);
+  BOOST_CHECK(get<0>(t4) > 5.4 && get<0>(t4) < 5.6);

  tuple<int, float> t5;
-  BOOST_TEST(get<0>(t5) == int());
-  BOOST_TEST(get<1>(t5) == float());
+  BOOST_CHECK(get<0>(t5) == int());
+  BOOST_CHECK(get<1>(t5) == float());

  tuple<int, float> t6(12, 5.5f);
-  BOOST_TEST(get<0>(t6) == 12);
-  BOOST_TEST(get<1>(t6) > 5.4f && get<1>(t6) < 5.6f);
+  BOOST_CHECK(get<0>(t6) == 12);
+  BOOST_CHECK(get<1>(t6) > 5.4f && get<1>(t6) < 5.6f);

  tuple<int, float> t7(t6);
-  BOOST_TEST(get<0>(t7) == 12);
-  BOOST_TEST(get<1>(t7) > 5.4f && get<1>(t7) < 5.6f);
+  BOOST_CHECK(get<0>(t7) == 12);
+  BOOST_CHECK(get<1>(t7) > 5.4f && get<1>(t7) < 5.6f);

  tuple<long, double> t8(t6);
-  BOOST_TEST(get<0>(t8) == 12);
-  BOOST_TEST(get<1>(t8) > 5.4f && get<1>(t8) < 5.6f);
+  BOOST_CHECK(get<0>(t8) == 12);
+  BOOST_CHECK(get<1>(t8) > 5.4f && get<1>(t8) < 5.6f);

  dummy(
    tuple<no_def_constructor, no_def_constructor, no_def_constructor>(
@ -147,12 +151,10 @@ 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
@ -165,7 +167,6 @@ 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);
@ -174,58 +175,40 @@ void element_access_test()
  int i  = get<0>(t);
  int i2 = get<3>(t);

-  BOOST_TEST(i == 1 && i2 == 2);
+  BOOST_CHECK(i == 1 && i2 == 2);

  int j  = get<0>(ct);
-  BOOST_TEST(j == 1);
+  BOOST_CHECK(j == 1);
   
  get<0>(t) = 5;
-  BOOST_TEST(t.head == 5);
+  BOOST_CHECK(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);
+  BOOST_CHECK(e > 2.69 && e < 2.71);
     
  get<1>(t) = 3.14+i;
-  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
+  BOOST_CHECK(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);
+  BOOST_CHECK(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
 }


@ -241,13 +224,13 @@ copy_test()
  tuple<int, char> t1(4, 'a');
  tuple<int, char> t2(5, 'b');
  t2 = t1;
-  BOOST_TEST(get<0>(t1) == get<0>(t2));
-  BOOST_TEST(get<1>(t1) == get<1>(t2));
+  BOOST_CHECK(get<0>(t1) == get<0>(t2));
+  BOOST_CHECK(get<1>(t1) == get<1>(t2));

  tuple<long, std::string> t3(2, "a");
  t3 = t1;
-  BOOST_TEST((double)get<0>(t1) == get<0>(t3));
-  BOOST_TEST(get<1>(t1) == get<1>(t3)[0]);
+  BOOST_CHECK((double)get<0>(t1) == get<0>(t3));
+  BOOST_CHECK(get<1>(t1) == get<1>(t3)[0]);

 // testing copy and assignment with implicit conversions between elements
 // testing tie
@ -259,9 +242,9 @@ copy_test()
  int i; char c; double d;
  tie(i, c, d) = make_tuple(1, 'a', 5.5);
  
-  BOOST_TEST(i==1);
-  BOOST_TEST(c=='a');
-  BOOST_TEST(d>5.4 && d<5.6);
+  BOOST_CHECK(i==1);
+  BOOST_CHECK(c=='a');
+  BOOST_CHECK(d>5.4 && d<5.6);
 }

 void
@ -273,10 +256,10 @@ mutate_test()
  get<2>(t1) = false;
  get<3>(t1) = foo(5);

-  BOOST_TEST(get<0>(t1) == 6);
-  BOOST_TEST(get<1>(t1) > 2.1f && get<1>(t1) < 2.3f);
-  BOOST_TEST(get<2>(t1) == false);
-  BOOST_TEST(get<3>(t1) == foo(5));
+  BOOST_CHECK(get<0>(t1) == 6);
+  BOOST_CHECK(get<1>(t1) > 2.1f && get<1>(t1) < 2.3f);
+  BOOST_CHECK(get<2>(t1) == false);
+  BOOST_CHECK(get<3>(t1) == foo(5));
 }

 // ----------------------------------------------------------------------------
@ -287,40 +270,36 @@ void
 make_tuple_test()
 {
  tuple<int, char> t1 = make_tuple(5, 'a');
-  BOOST_TEST(get<0>(t1) == 5);
-  BOOST_TEST(get<1>(t1) == 'a');
+  BOOST_CHECK(get<0>(t1) == 5);
+  BOOST_CHECK(get<1>(t1) == 'a');

  tuple<int, std::string> t2;
  t2 = make_tuple((short int)2, std::string("Hi"));
-  BOOST_TEST(get<0>(t2) == 2);
-  BOOST_TEST(get<1>(t2) == "Hi");
+  BOOST_CHECK(get<0>(t2) == 2);
+  BOOST_CHECK(get<1>(t2) == "Hi");


-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-    A a; B b;
+    A a = A(); B b;
    const A ca = a;
-    make_tuple(cref(a), b);
-    make_tuple(ref(a), b);
-    make_tuple(ref(a), cref(b));
+    make_tuple(boost::cref(a), b);
+    make_tuple(boost::ref(a), b);
+    make_tuple(boost::ref(a), boost::cref(b));

-    make_tuple(ref(ca));
-#endif
+    make_tuple(boost::ref(ca));
     
 // the result of make_tuple is assignable:
-   BOOST_TEST(make_tuple(2, 4, 6) == 
+   BOOST_CHECK(make_tuple(2, 4, 6) == 
             (make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));

-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    make_tuple("Donald", "Daisy"); // should work;
-#endif
+#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
@ -357,19 +336,19 @@ tie_test()
  foo c(5);

  tie(a, b, c) = make_tuple(2, 'a', foo(3));
-  BOOST_TEST(a == 2);
-  BOOST_TEST(b == 'a');
-  BOOST_TEST(c == foo(3));
+  BOOST_CHECK(a == 2);
+  BOOST_CHECK(b == 'a');
+  BOOST_CHECK(c == foo(3));

  tie(a, tuples::ignore, c) = make_tuple((short int)5, false, foo(5));
-  BOOST_TEST(a == 5);
-  BOOST_TEST(b == 'a');
-  BOOST_TEST(c == foo(5));
+  BOOST_CHECK(a == 5);
+  BOOST_CHECK(b == 'a');
+  BOOST_CHECK(c == foo(5));

 // testing assignment from std::pair
   int i, j; 
   tie (i, j) = std::make_pair(1, 2);
-   BOOST_TEST(i == 1 && j == 2);
+   BOOST_CHECK(i == 1 && j == 2);

   tuple<int, int, float> ta;
 #ifdef E11
@ -389,13 +368,13 @@ equality_test()
 {
  tuple<int, char> t1(5, 'a');
  tuple<int, char> t2(5, 'a');
-  BOOST_TEST(t1 == t2);
+  BOOST_CHECK(t1 == t2);

  tuple<int, char> t3(5, 'b');
  tuple<int, char> t4(2, 'a');
-  BOOST_TEST(t1 != t3);
-  BOOST_TEST(t1 != t4);
-  BOOST_TEST(!(t1 != t2));
+  BOOST_CHECK(t1 != t3);
+  BOOST_CHECK(t1 != t4);
+  BOOST_CHECK(!(t1 != t2));
 }


@ -409,14 +388,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_TEST(t1 < t2);
-  BOOST_TEST(t1 <= t2);
-  BOOST_TEST(t2 > t1);
-  BOOST_TEST(t2 >= t1);
-  BOOST_TEST(t2 < t3);
-  BOOST_TEST(t2 <= t3);
-  BOOST_TEST(t3 > t2);
-  BOOST_TEST(t3 >= t2);
+  BOOST_CHECK(t1 < t2);
+  BOOST_CHECK(t1 <= t2);
+  BOOST_CHECK(t2 > t1);
+  BOOST_CHECK(t2 >= t1);
+  BOOST_CHECK(t2 < t3);
+  BOOST_CHECK(t2 <= t3);
+  BOOST_CHECK(t3 > t2);
+  BOOST_CHECK(t3 >= t2);

 }

@ -426,7 +405,6 @@ ordering_test()
 // ----------------------------------------------------------------------------
 void cons_test()
 {
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  using tuples::cons;
  using tuples::null_type;

@ -434,11 +412,10 @@ 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_TEST(make_tuple(3,2,1)==c);
+  BOOST_CHECK(make_tuple(3,2,1)==c);

  cons<char, cons<int, cons<float, null_type> > > x;
  dummy(x);
-#endif
 }

 // ----------------------------------------------------------------------------
@ -447,8 +424,8 @@ void cons_test()
 void const_tuple_test()
 {
  const tuple<int, float> t1(5, 3.3f);
-  BOOST_TEST(get<0>(t1) == 5);
-  BOOST_TEST(get<1>(t1) == 3.3f);
+  BOOST_CHECK(get<0>(t1) == 5);
+  BOOST_CHECK(get<1>(t1) == 3.3f);
 }

 // ----------------------------------------------------------------------------
Author	SHA1	Message	Date
Daniel James	47854e0ef4	Branch for adding initializer list support (only in the unreleased gcc 4.4 at the moment). [SVN r48931]	2008-09-23 19:45:43 +00:00
Beman Dawes	a30a7f9604	With his kind permission, change Jaakko "Järvi" to "Jarvi" [SVN r46808]	2008-06-28 13:45:21 +00:00
Daniel James	62d366fa68	Link to people pages on the website, as they've been removed from the download. [SVN r43209]	2008-02-10 14:56:22 +00:00
Vladimir Prus	d08c9bfab1	Update to V2 [SVN r38530]	2007-08-08 19:42:04 +00:00
Jaakko Järvi	19b8004830	Fixed a typo. [SVN r36896]	2007-02-06 00:23:26 +00:00
Daniel James	0af5b76442	Merge fixed links from RC_1_34_0. [SVN r36660]	2007-01-07 23:50:56 +00:00
Beman Dawes	defe1c94d6	Add copyright, license [SVN r35905]	2006-11-07 19:11:57 +00:00
Ralf W. Grosse-Kunstleve	76c2151830	avoid g++ -Wall -W "unused parameter" warnings [SVN r32373]	2006-01-22 19:29:32 +00:00
Jaakko Järvi	2d13a60d05	applied patch by Rupert Kittinger, avoids potentially undefined behavior [SVN r30690]	2005-08-26 16:03:05 +00:00
John Maddock	9c6ef41dfe	Large patch from Ulrich Eckhardt to fix support for EVC++ 4. [SVN r30670]	2005-08-25 16:27:28 +00:00
Douglas Gregor	5686969287	Merged from 1.33.0 release [SVN r30540]	2005-08-12 13:02:37 +00:00
Stefan Slapeta	a17ce206f2	replaced BOOST_TEST [SVN r27057]	2005-02-03 13:55:45 +00:00
Joaquín M. López Muñoz	34690282fe	fixes in element<> for BCB compilers, with help from Tobias Schwinger [SVN r25763]	2004-10-18 06:03:18 +00:00
Aleksey Gurtovoy	bc3d37ec2b	c++boost.gif -> boost.png replacement [SVN r25573]	2004-10-05 15:45:52 +00:00
Douglas Gregor	eea1937afc	Converted to Boost Software License, Version 1.0 [SVN r24096]	2004-07-27 03:43:34 +00:00
Douglas Gregor	8820994ffd	Doug Gregor -> Douglas Gregor [SVN r24016]	2004-07-25 02:29:29 +00:00
Toon Knapen	045d761ab5	suppressed scoping the call get_class to the detail namespace [SVN r23113]	2004-06-17 13:51:33 +00:00
Toon Knapen	63c93b59b4	port to vacpp: added default template arguments explicitly (Joaquin M Lopez) removed member template keyword (Toon Knapen) [SVN r23109]	2004-06-17 07:01:13 +00:00
Dave Abrahams	78572fca7b	Bug fix for vc6 [SVN r20866]	2003-11-19 22:01:52 +00:00
Joel de Guzman	ad29f96e5b	updated swallow_assign constness bug [SVN r20520]	2003-10-28 09:42:43 +00:00
Joel de Guzman	9734556efe	made "ingnore" a const object to avoid linker errors [SVN r20449]	2003-10-21 23:25:17 +00:00
Jaakko Järvi	c8e03a518b	added praise for Dave for improving tuple support on non-partial template specialization compilers [SVN r19965]	2003-09-08 15:10:04 +00:00
Dave Abrahams	e4b869219b	More complete functionality for compilers without partial specialization. [SVN r19925]	2003-09-05 16:52:55 +00:00
Dave Abrahams	eef0e01c8d	Adjust for changed test library name [SVN r19924]	2003-09-05 16:18:53 +00:00
Jaakko Järvi	41d649b08c	cleaning up after previous commit [SVN r19688]	2003-08-18 19:35:29 +00:00
Jaakko Järvi	122bf636f5	getting rid of some library specific macros and using BOOST_NO_EXPLICIT_- FUNCTION_TEMPLATE_ARGUMENTS related helper macros from the config library [SVN r19687]	2003-08-18 19:33:47 +00:00
Jaakko Järvi	359eaeecbf	added tests to ensure correct constness behaviour [SVN r18871]	2003-06-26 15:19:01 +00:00
Jaakko Järvi	28e34eb757	fixed a typo [SVN r18386]	2003-05-12 14:51:42 +00:00
Dave Abrahams	5ea6623d49	restore from disk crash [SVN r18353]	2003-05-08 02:19:10 +00:00
Jaakko Järvi	d349450992	fixed a few links [SVN r18344]	2003-05-07 16:01:33 +00:00
Jaakko Järvi	8b4daa1385	patch of a patch [SVN r17706]	2003-03-03 16:45:55 +00:00
Jaakko Järvi	1972959fda	element<T>::type takes constness into consideration [SVN r17666]	2003-02-26 23:10:55 +00:00
Jaakko Järvi	496cc84960	a patch for borland [SVN r17660]	2003-02-26 16:04:56 +00:00
Jaakko Järvi	c1a28e5d81	typofix [SVN r17557]	2003-02-20 15:30:48 +00:00
Björn Karlsson	4d4fe0010f	Added copyright statement [SVN r17193]	2003-02-04 11:54:01 +00:00
Dave Abrahams	8992af95d1	Link bug workaround for MSVC and old Dec CXX [SVN r16342]	2002-11-20 13:17:52 +00:00
Jaakko Järvi	ae40fce7c9	added namespace qualifiers to make MIPS PRO happy [SVN r16033]	2002-10-31 18:14:29 +00:00
Jaakko Järvi	607b65a946	fixing a borland warning [SVN r15810]	2002-10-08 19:24:36 +00:00
Jaakko Järvi	2c213c8295	fix one borland warning [SVN r15808]	2002-10-08 18:43:52 +00:00
Jaakko Järvi	5b8506c39b	typo fixes [SVN r15652]	2002-10-02 16:51:43 +00:00
Jaakko Järvi	22f56bbe58	fixed Bemans name in a comment [SVN r15594]	2002-10-01 03:26:10 +00:00
Ralf W. Grosse-Kunstleve	fb8fa3c7b6	work-around for MIPSpro bug [SVN r15574]	2002-09-30 19:45:22 +00:00
Dave Abrahams	cc5a2ae388	Fixes which make it possible to declare with reference elements [SVN r15532]	2002-09-28 07:25:27 +00:00
Jaakko Järvi	4cd544f4c1	applied patch Markus Schöpflin, ::template replaced with ::BOOST_NESTED_TEMPLATE [SVN r15466]	2002-09-20 15:55:10 +00:00
Jaakko Järvi	74a2ab1242	changed jamfile includes from <include> to <sysinclude> [SVN r15305]	2002-09-13 16:26:12 +00:00
Jaakko Järvi	7896766f8f	a fix of a fix [SVN r15278]	2002-09-12 20:59:05 +00:00
Jaakko Järvi	0a33edd21d	workaround for isspace and metrowerks [SVN r15277]	2002-09-12 20:50:10 +00:00
Jaakko Järvi	53c1bb2c20	removed an extraneous include [SVN r14993]	2002-08-20 15:54:11 +00:00
Jaakko Järvi	ea8d71487d	workaround for boost test library problem [SVN r14992]	2002-08-20 15:51:36 +00:00
Jaakko Järvi	6a92d10f25	added a redirection index.html file [SVN r14898]	2002-08-15 18:26:17 +00:00
Jaakko Järvi	3570bdb6b6	fixed some warningns about unused variables, added Jamfile [SVN r14854]	2002-08-14 20:55:52 +00:00