moved some tests that require user interaction from tuple_test_bench.cpp

to another_tuple_test_bench.cpp [SVN r11059]
tuples in separate namespaces now compile under MSVC++ as well
2025-06-26 12:31:55 +02:00 · 2001-09-07 11:04:50 +00:00 · 2001-09-07 11:02:01 +00:00 · 2001-09-06 22:25:15 +00:00 · 2001-09-06 13:51:22 +00:00 · 2001-09-06 13:50:27 +00:00
16 changed files with 617 additions and 1833 deletions
--- a/doc/design_decisions_rationale.html
+++ b/doc/design_decisions_rationale.html
@ -1,153 +0,0 @@
-<html>
-
-<title>Design decisions rationale for Boost Tuple Library</title>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<IMG SRC="../../../boost.png" 
-     ALT="C++ Boost" width="277" height="86">
-
-<h1>Tuple Library : design decisions rationale</h1>
-
-<h2>About namespaces</h2>
-
-<p>
-There was a discussion about whether tuples should be in a separate namespace or directly in the <code>boost</code> namespace.
-The common principle is that domain libraries (like <i>graph</i>, <i>python</i>) should be on a separate
-subnamespace, while utility like libraries directly in the <code>boost</code> namespace.
-Tuples are somewhere in between, as the tuple template is clearly a general utility, but the library introduces quite a lot of names in addition to just the tuple template. 
-Tuples were originally under a subnamespace.
-As a result of the discussion, tuple definitions were moved directly under the <code>boost</code> namespace.
-As a result of a continued discussion, the subnamespace was reintroduced.
-The final (I truly hope so) solution is now to have all definitions in namespace <code>::boost::tuples</code>, and the most common names in the <code>::boost</code> namespace as well. 
-This is accomplished with using declarations (suggested by Dave Abrahams):
-<code><pre>namespace boost {
-  namespace tuples {
-      ...      
-    // All library code
-      ...
-  }
-  using tuples::tuple; 
-  using tuples::make_tuple;
-  using tuples::tie;
-  using tuples::get;
-}
-</pre></code>
-With this arrangement, tuple creation with direct constructor calls, <code>make_tuple</code> or <code>tie</code> functions do not need the namespace qualifier.
-Further, all functions that manipulate tuples are found with Koenig-lookup.
-The only exceptions are the <code>get&lt;N&gt;</code> functions, which are always called with an explicitly qualified template argument, and thus Koenig-lookup does not apply.
-Therefore, get is lifted to <code>::boost</code> namespace with a using declaration.
-Hence, the interface for an application programmer is in practice under the namespace <code>::boost</code>.
-</p>
-<p>
-The other names, forming an interface for library writers (cons lists, metafunctions manipulating cons lists, ...) remain in the subnamespace <code>::boost::tuples</code>.
-Note, that the names <code>ignore</code>, <code>set_open</code>, <code>set_close</code> and <code>set_delimiter</code> are considered to be part of the application programmer's interface, but are still not under <code>boost</code> namespace. 
-The reason being the danger for name clashes for these common names.
-Further, the usage of these features is probably not very frequent.
-</p>
-
-<h4>For those who are really interested in namespaces</h4>
-
-<p>
-The subnamespace name <i>tuples</i> raised some discussion.
-The rationale for not using the most natural name 'tuple' is to avoid having an identical name with the tuple template. 
-Namespace names are, however, not generally in plural form in boost libraries. 
-First, no real trouble was reported for using the same name for a namespace and a class and we considered changing the name 'tuples' to 'tuple'.
-But we found some trouble after all.
-Both gcc and edg compilers reject using declarations where the namespace and class names are identical:
-
-<code><pre>namespace boost {
-  namespace tuple {
-    ... tie(...);
-    class tuple; 
-&nbsp;     ...
-  }
-  using tuple::tie; // ok
-  using tuple::tuple; // error
-    ...
-}
-</pre></code>
-
-Note, however, that a corresponding using declaration in the global namespace seems to be ok: 
-
-<code><pre>
-using boost::tuple::tuple; // ok;
-</pre></code>
-
-
-<h2>The end mark of the cons list (nil, null_type, ...)</h2>
-
-<p>
-Tuples are internally represented as <code>cons</code> lists:
-
-<code><pre>tuple&lt;int, int&gt;
-</pre></code> 
-inherits from 
-<code><pre>cons&lt;int, cons&lt;int, null_type&gt; &gt;
-</code></pre>
-
-<code>null_type</code> is the end mark of the list. Original proposition was <code>nil</code>, but the name is used in MacOS, and might have caused problems, so <code>null_type</code> was chosen instead.
-Other names considered were <i>null_t</i> and <i>unit</i> (the empty tuple type in SML).
-<p>
-Note that <code>null_type</code> is the internal representation of an empty tuple: <code>tuple&lt;&gt;</code> inherits from <code>null_type</code>.
-</p>
-
-<h2>Element indexing</h2>
-
-<p>
-Whether to use 0- or 1-based indexing was discussed more than thoroughly, and the following observations were made:
-
-<ul>
-<li> 0-based indexing is 'the C++ way' and used with arrays etc.</li>
-<li> 1-based 'name like' indexing exists as well, eg. <code>bind1st</code>, <code>bind2nd</code>, <code>pair::first</code>, etc.</li>
-</ul>
-Tuple access with the syntax <code>get&lt;N&gt;(a)</code>, or <code>a.get&lt;N&gt;()</code> (where <code>a</code> is a tuple and <code>N</code> an index), was considered to be of the first category, hence, the index of the first element in a tuple is 0.
-
-<p>
-A suggestion to provide 1-based 'name like' indexing with constants like <code>_1st</code>, <code>_2nd</code>, <code>_3rd</code>, ... was made.
-By suitably chosen constant types, this would allow alternative syntaxes:
-
-<code><pre>a.get&lt;0&gt;() == a.get(_1st) == a[_1st] == a(_1st);
-</pre></code>
-
-We chose not to provide more than one indexing method for the following reasons:
-<ul>
-<li>0-based indexing might not please everyone, but once its fixed, it is less confusing than having two different methods (would anyone want such constants for arrays?).</li>
-<li>Adding the other indexing scheme doesn't really provide anything new (like a new feature) to the user of the library.</li>
-<li>C++ variable and constant naming rules don't give many possibilities for defining short and nice index constants (like <code>_1st</code>, ...). 
-Let the binding and lambda libraries use these for a better purpose.</li>
-<li>The access syntax <code>a[_1st]</code> (or <code>a(_1st)</code>) is appealing, and almost made us add the index constants after all. However, 0-based subscripting is so deep in C++, that we had a fear for confusion.</li>
-<li>
-Such constants are easy to add.
-</li>
-</ul>
-
-
-<h2>Tuple comparison</h2>
-
-The comparison operator implements lexicographical order. 
-Other orderings were considered, mainly dominance (<i>a &lt; b iff for each i a(i) < b(i)</i>). 
-Our belief is, that lexicographical ordering, though not mathematically the most natural one, is the most frequently needed ordering in everyday programming.
-
-<h2>Streaming</h2>
-
-<p>
-The characters specified with tuple stream manipulators are stored within the space allocated by <code>ios_base::xalloc</code>, which allocates storage for <code>long</code> type objects.
-<code>static_cast</code> is used in casting between <code>long</code> and the stream's character type. 
-Streams that have character types not convertible back and forth to long thus fail to compile.
-
-This may be revisited at some point. The two possible solutions are:
-<ul>
-<li>Allow only plain <code>char</code> types as the tuple delimiters and use <code>widen</code> and <code>narrow</code> to convert between the real character type of the stream. 
-This would always compile, but some calls to set manipulators might result in a different
-  character than expected (some default character).</li>
-<li>Allocate enough space to hold the real character type of the stream. 
-This means memory for holding the delimiter characters must be allocated separately, and that pointers to this memory are stored in the space allocated with <code>ios_base::xalloc</code>.
-Any volunteers?</li>
-</ul>
-
-<A href="tuple_users_guide.html">Back to the user's guide</A>
-<hr><p>&copy; Copyright Jaakko J&auml;rvi 2001. 
-</body>
-</html>
-
--- a/doc/tuple_advanced_interface.html
+++ b/doc/tuple_advanced_interface.html
@ -1,135 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-  <head>
-    <title>Tuple library advanced features</title>
-<body bgcolor="#FFFFFF" text="#000000">
-
-<IMG SRC="../../../boost.png" 
-     ALT="C++ Boost" width="277" height="86">
-
-  </head>
-
-  <body>
-    <h1>Tuple library advanced features</h1>
-
-The advanced features described in this document are all under namespace <code>::boost::tuples</code>
-
-<h2>Metafunctions for tuple types</h2>
-<p>
-Suppose <code>T</code> is a tuple type, and <code>N</code> is a constant integral expression. 
-
-<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. 
-Note that the constness of <code>T</code> does not affect reference type
-elements.
-</p>
-
-<code><pre>length&lt;T&gt;::value</pre></code>
-
-gives the length of the tuple type <code>T</code>.
-</p>
-
-<h2>Cons lists</h2>
-
-<p>
-Tuples are internally represented as <i>cons lists</i>.
-For example, the tuple 
-
-<code><pre>tuple&lt;A, B, C, D&gt;</pre></code>
-
- inherits from the type
-<code><pre>cons&lt;A, cons&lt;B, cons&lt;C, cons&lt;D, null_type&gt; &gt; &gt; &gt;
-</pre></code>
-
-The tuple template provides the typedef <code>inherited</code> to access the cons list representation. E.g.:
-<code>tuple&lt;A&gt;::inherited</code> is the type <code>cons&lt;A, null_type&gt;</code>.
-</p>
-
-<h4>Empty tuple</h4>
-<p>
-The internal representation of the empty tuple <code>tuple&lt;&gt</code> is <code>null_type</code>.
-</p>
-
-<h4>Head and tail</h4>
-<p>
-Both tuple template and the cons templates provide the typedefs <code>head_type</code> and <code>tail_type</code>.
-The <code>head_type</code> typedef gives the type of the first element of the tuple (or the cons list).
-The 
-<code>tail_type</code> typedef gives the remaining cons list after removing the first element.
-The head element is stored in the member variable <code>head</code> and the tail list in the member variable <code>tail</code>.
-Cons lists provide the member function <code>get_head()</code> for getting a reference to the head of a cons list, and <code>get_tail()</code> for getting a reference to the tail.
-There are const and non-const versions of both functions.
-</p>
-<p>
-Note that in a one element tuple, <code>tail_type</code> equals <code>null_type</code> and the <code>get_tail()</code> function returns an object of type <code>null_type</code>.
-</p>
-<p>
-The empty tuple (<code>null_type</code>) has no head or tail, hence the <code>get_head</code> and <code>get_tail</code> functions are not provided.
-</p>
-
-<p>
-Treating tuples as cons lists gives a convenient means to define generic functions to manipulate tuples. For example, the following pair of function templates assign 0 to each element of a tuple (obviously, the assignments must be valid operations for the element types):
-
-<pre><code>inline void set_to_zero(const null_type&amp;) {};
-
-template &lt;class H, class T&gt;
-inline void set_to_zero(cons&lt;H, T&gt;&amp; x) { x.get_head() = 0; set_to_zero(x.get_tail()); }
-</code></pre>
-<p>
-
-<h4>Constructing cons lists</h4>
-
-<p>
-A cons list can be default constructed provided that all its elements can be default constructed.
-</p>
-<p>
-A cons list can be constructed from its head and tail. The prototype of the constructor is:
-<pre><code>cons(typename access_traits&lt;head_type&gt;::parameter_type h,
-     const tail_type&amp; t)
-</code></pre>
-The traits template for the head parameter selects correct parameter types for different kinds of element types (for reference elements the parameter type equals the element type, for non-reference types the parameter type is a reference to const non-volatile element type).
-</p>
-<p>
-For a one-element cons list the tail argument (<code>null_type</code>) can be omitted.
-</p>
-
-
-<h2>Traits classes for tuple element types</h2>
-
-<h4><code>access_traits</code></h4>
-<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;::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>
-<h4><code>make_tuple_traits</code></h4>
-
-The element types of the tuples that are created with the <code>make_tuple</code> functions are computed with the type function <code>make_tuple_traits</code>. 
-The type function call <code>make_tuple_traits&lt;T&gt;::type</code> implements the following type mapping:
-<ul>
-<li><i>any reference type</i> -&gt; <i>compile time error</i>
-</li>
-<li><i>any array type</i> -&gt; <i>constant reference to the array type</i>
-</li>
-<li><code>reference_wrapper&lt;T&gt;</code> -&gt; <code>T&amp;</code>
-</li>
-<li><code>T</code> -&gt; <code>T</code>
-</li>
-</ul>
-
-Objects of type <code>reference_wrapper</code> are created with the <code>ref</code> and <code>cref</code> functions (see <A href="tuple_users_guide.html#make_tuple">The <code>make_tuple</code> function</A>.)
-</p>
-
-<p>Reference wrappers were originally part of the tuple library, but they are now a general utility of boost. 
-The <code>reference_wrapper</code> template and the <code>ref</code> and <code>cref</code> functions are defined in a separate file <code>ref.hpp</code> in the main boost include directory; and directly in the <code>boost</code> namespace.
-</p>
-
-<A href="tuple_users_guide.html">Back to the user's guide</A>
-<hr>
-
-<p>&copy; Copyright Jaakko J&auml;rvi 2001.</p>
-  </body>
-</html>
--- a/doc/tuple_users_guide.html
+++ b/doc/tuple_users_guide.html
@ -1,529 +0,0 @@
-<html>
-<head>
-<title>The Boost Tuple Library</title>
-</head>
-<body bgcolor="#FFFFFF" text="#000000">
-
-<IMG SRC="../../../boost.png" 
-     ALT="C++ Boost" width="277" height="86">
-
-<h1>The Boost Tuple Library</h1>
-
-<p>
-A tuple (or <i>n</i>-tuple) is a fixed size collection of elements. 
-Pairs, triples, quadruples etc. are tuples. 
-In a programming language, a tuple is a data object containing other objects as elements. 
-These element objects may be of different types.
-</p>
-
-<p>Tuples are convenient in many circumstances. 
-For instance, tuples make it easy to define functions that return more than one value.
-</p>
-
-<p>
-Some programming languages, such as ML, Python and Haskell, have built-in tuple constructs. 
-Unfortunately C++ does not.
-To compensate for this &quot;deficiency&quot;, the Boost Tuple Library implements a tuple construct using templates.
-</p>
-
-<h2>Table of Contents</h2>
-
-<ol>
-<li><a href = "#using_library">Using the library</a></li>
-<li><a href = "#tuple_types">Tuple types</a></li>
-<li><a href = "#constructing_tuples">Constructing tuples</a></li>
-<li><a href = "#accessing_elements">Accessing tuple elements</a></li>
-<li><a href = "#construction_and_assignment">Copy construction and tuple assignment</a></li>
-<li><a href = "#relational_operators">Relational operators</a></li>
-<li><a href = "#tiers">Tiers</a></li>
-<li><a href = "#streaming">Streaming</a></li>
-<li><a href = "#performance">Performance</a></li>
-<li><a href = "#portability">Portability</a></li>
-<li><a href = "#thanks">Acknowledgements</a></li>
-<li><a href = "#references">References</a></li>
-</ol>
-
-<h4>More details</h4>
-
-<p>
-<a href = "tuple_advanced_interface.html">Advanced features</a> (describes some metafunctions etc.).</p>
-<p>
-<a href = "design_decisions_rationale.html">Rationale behind some design/implementation decisions.</a></p>
-
-
-<h2><a name="using_library">Using the library</a></h2>
-
-<p>To use the library, just include:
-
-<pre><code>#include &quot;boost/tuple/tuple.hpp&quot;</code></pre>
-
-<p>Comparison operators can be included with:
-<pre><code>#include &quot;boost/tuple/tuple_comparison.hpp&quot;</code></pre>
-
-<p>To use tuple input and output operators,
-
-<pre><code>#include &quot;boost/tuple/tuple_io.hpp&quot;</code></pre>
-
-Both <code>tuple_io.hpp</code> and <code>tuple_comparison.hpp</code> include <code>tuple.hpp</code>.
-
-<p>All definitions are in namespace <code>::boost::tuples</code>, but the most common names are lifted to namespace <code>::boost</code> with using declarations. These names are: <code>tuple</code>, <code>make_tuple</code>, <code>tie</code> and <code>get</code>. Further, <code>ref</code> and <code>cref</code> are defined directly under the <code>::boost</code> namespace.
-
-<h2><a name = "tuple_types">Tuple types</a></h2>
-
-<p>A tuple type is an instantiation of the <code>tuple</code> template. 
-The template parameters specify the types of the tuple elements.
-The current version supports tuples with 0-10 elements. 
-If necessary, the upper limit can be increased up to, say, a few dozen elements.
-The data element can be any C++ type.
-Note that <code>void</code> and plain function types are valid 
-C++ types, but objects of such types cannot exist. 
-Hence, if a tuple type contains such types as elements, the tuple type
-can exist, but not an object of that type.
-There are natural limitations for element types that cannot
-be be copied, or that are not default constructible (see 'Constructing tuples'
- below). 
-
-<p>
-For example, the following definitions are valid tuple instantiations (<code>A</code>, <code>B</code> and <code>C</code> are some user defined classes):
-
-<pre><code>tuple&lt;int&gt;
-tuple&lt;double&amp;, const double&amp;, const double, double*, const double*&gt;
-tuple&lt;A, int(*)(char, int), B(A::*)(C&amp;), C&gt;
-tuple&lt;std::string, std::pair&lt;A, B&gt; &gt;
-tuple&lt;A*, tuple&lt;const A*, const B&amp;, C&gt;, bool, void*&gt;
-</code></pre>
-
-<h2><a name = "constructing_tuples">Constructing tuples</a></h2>
-
-<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 example:
-<pre><code>tuple&lt;int, double&gt;() 
-tuple&lt;int, double&gt;(1) 
-tuple&lt;int, double&gt;(1, 3.14)
-</code></pre>
-
-<p>
-If no initial value for an element is provided, it is default initialized (and hence must be default initializable).
-For example.
-
-<pre><code>class X {
-  X(); 
-public:
-  X(std::string);
-};
-
-tuple&lt;X,X,X&gt;()                                              // error: no default constructor for X
-tuple&lt;X,X,X&gt;(string(&quot;Jaba&quot;), string(&quot;Daba&quot;), string(&quot;Duu&quot;)) // ok
-</code></pre>
-
-In particular, reference types do not have a default initialization: 
-
-<pre><code>tuple&lt;double&amp;&gt;()                // error: reference must be 
-                                // initialized explicitly
-
-double d = 5; 
-tuple&lt;double&amp;&gt;(d)               // ok
-
-tuple&lt;double&amp;&gt;(d+3.14)          // error: cannot initialize 
-                                // non-const reference with a temporary
-
-tuple&lt;const double&amp;&gt;(d+3.14)    // ok, but dangerous: 
-                                // the element becomes a dangling reference 
-</code></pre>
-
-<p>Using an initial value for an element that cannot be copied, is a compile
-time error:
-
-<pre><code>class Y { 
-  Y(const Y&amp;); 
-public:
-  Y();
-};
-
-char a[10];
-
-tuple&lt;char[10], Y&gt;(a, Y()); // error, neither arrays nor Y can be copied
-tuple&lt;char[10], Y&gt;();       // ok
-</code></pre>
-
-Note particularly that the following is perfectly ok:
-<code><pre>Y y;
-tuple&lt;char(&amp;)[10], Y&amp;&gt;(a, y); 
-</code></pre>
-
-It is possible to come up with a tuple type that cannot be constructed.
-This occurs if an element that cannot be initialized has a lower
-index than an element that requires initialization. 
-For example: <code>tuple&lt;char[10], int&amp;&gt;</code>.
-
-<p>In sum, the tuple construction is semantically just a group of individual elementary constructions.
-</p>
-
-<h4><a name="make_tuple">The <code>make_tuple</code> function</a></h4>
-
-<p>
-Tuples can also be constructed using the <code>make_tuple</code> (cf. <code>std::make_pair</code>) helper functions.
-This makes the construction more convenient, saving the programmer from explicitly specifying the element types: 
-<pre><code>tuple&lt;int, int, double&gt; add_multiply_divide(int a, int b) {
-  return make_tuple(a+b, a*b, double(a)/double(b));
-}
-</code></pre>
-
-<p>
-By default, the element types are deduced to the plain non-reference types. E.g: 
-<pre><code>void foo(const A&amp; a, B&amp; b) { 
-  ...
-  make_tuple(a, b);
-</code></pre>
-The <code>make_tuple</code> invocation results in a tuple of type <code>tuple&lt;A, B&gt;</code>.
-
-<p>
-Sometimes the plain non-reference type is not desired, e.g. if the element type cannot be copied. 
-Therefore, the programmer can control the type deduction and state that a reference to const or reference to
-non-const type should be used as the element type instead.
-This is accomplished with two helper template functions: <code>ref</code> and <code>cref</code>. 
-Any argument can be wrapped with these functions to get the desired type. 
-The mechanism does not compromise const correctness since a const object wrapped with <code>ref</code> results in a tuple element with const reference type (see the fifth code line below).
-For example:
-
-<pre><code>A a; B b; const A ca = a;
-make_tuple(cref(a), b);      // creates tuple&lt;const A&amp;, B&gt;
-make_tuple(ref(a), b);       // creates tuple&lt;A&amp;, B&gt;
-make_tuple(ref(a), cref(b)); // creates tuple&lt;A&amp;, const B&amp;&gt;
-make_tuple(cref(ca));        // creates tuple&lt;const A&amp;&gt;
-make_tuple(ref(ca));         // creates tuple&lt;const A&amp;&gt;
-</code></pre>
-
-
-<p>
-Array arguments to <code>make_tuple</code> functions are deduced to reference to const types by default; there is no need to wrap them with <code>cref</code>. For example:
-<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> 
-(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.
-
-<p>
-Function pointers are deduced to the plain non-reference type, that is, to plain function pointer. 
-A tuple can also hold a reference to a function, 
-but such a tuple cannot be constructed with <code>make_tuple</code> (a const qualified function type would result, which is illegal):
-<pre><code>void f(int i);
-  ...
-make_tuple(&amp;f); // tuple&lt;void (*)(int)&gt;
-  ...
-tuple&lt;tuple&lt;void (&amp;)(int)&gt; &gt; a(f) // ok
-make_tuple(f);                    // not ok
-</code></pre>
-
-<h2><a name = "accessing_elements">Accessing tuple elements</a></h2>
-
-<p>
-Tuple elements are accessed with the expression:
-
-<pre><code>t.get&lt;N&gt;()
-</code></pre>
-or
-<pre><code>get&lt;N&gt;(t)
-</code></pre>
-where <code>t</code> is a tuple object and <code>N</code> is a constant integral expression specifying the index of the element to be accessed.
-Depending on whether <code>t</code> is const or not, <code>get</code> returns the <code>N</code>th element as a reference to const or
-non-const type.
-The index of the first element is 0 and thus<code>
-N</code> must be between 0 and <code>k-1</code>, where <code>k</code> is the number of elements in the tuple. 
-Violations of  these constrains are detected at compile time. Examples:
-
-<pre><code>double d = 2.7; A a;
-tuple&lt;int, double&amp;, const A&amp;&gt; t(1, d, a);
-const tuple&lt;int, double&amp;, const A&amp;&gt; ct = t;
-  ...
-int i = get&lt;0&gt;(t); i = t.get&lt;0&gt;();        // ok
-int j = get&lt;0&gt;(ct);                       // ok
-get&lt;0&gt;(t) = 5;                            // ok 
-get&lt;0&gt;(ct) = 5;                           // error, can't assign to const 
-  ...
-double e = get&lt;1&gt;(t); // ok   
-get&lt;1&gt;(t) = 3.14;     // ok 
-get&lt;2&gt;(t) = A();      // error, can't assign to const 
-A aa = get&lt;3&gt;(t);     // error: index out of bounds 
-  ...
-++get&lt;0&gt;(t);  // ok, can be used as any variable
-</code></pre>
-
-Note! The member get functions are not supported with MS Visual C++ compiler.
-Further, the compiler has trouble with finding the non-member get functions without an explicit namespace qualifier. 
-Hence, all <code>get</code> calls should be qualified as: <code>tuples::get&lt;N&gt;(a_tuple)</code> when writing code that shoud compile with MSVC++ 6.0.
-
-<h2><a name = "construction_and_assignment">Copy construction and tuple assignment</a></h2>
-
-<p>
-A tuple can be copy constructed from another tuple, provided that the element types are element-wise copy constructible.
-Analogously, a tuple can be assigned to another tuple, provided that the element types are element-wise assignable.
-For example:
-
-<pre><code>class A {};
-class B : public A {};
-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 
-a = t;                     // ok 
-</code></pre>
-
-In both cases, the conversions performed are: <code>char -> int</code>, <code>B* -> A*</code> (derived class pointer to base class pointer),  <code>B -> C</code> (a user defined conversion) and <code>D -> C</code> (a user defined conversion).
-
-<p>
-Note that assignment is also defined from <code>std::pair</code> types:
-
-<pre><code>tuple&lt;float, int&gt; a = std::make_pair(1, 'a');
-</code></pre>
-
-<h2><a name = "relational_operators">Relational operators</a></h2>
-<p>
-Tuples reduce the operators <code>==, !=, &lt;, >, &lt;=</code> and <code>>=</code> to the corresponding elementary operators. 
-This means, that if any of these operators is defined between all elements of two tuples, then the same operator is defined between the tuples as well.
-
-The equality operators for two tuples <code>a</code> and <code>b</code> are defined as:
-<ul>
-<li><code>a == b</code> iff for each <code>i</code>: <code>a<sub>i</sub> == b<sub>i</sub></code></li>
-<li><code>a != b</code> iff exists <code>i</code>: <code>a<sub>i</sub> != b<sub>i</sub></code></li>
-</ul>
-
-The operators <code>&lt;, >, &lt;=</code> and <code>>=</code> implement a lexicographical ordering.
-
-<p>
-Note that an attempt to compare two tuples of different lengths results in a compile time error.</p>
-Also, the comparison operators are <i>"short-circuited"</i>: elementary comparisons start from the first elements and are performed only until the result is clear.
-
-<p>Examples:
-
-<pre><code>tuple&lt;std::string, int, A&gt; t1(std::string(&quot;same?&quot;), 2, A());
-tuple&lt;std::string, long, A&gt; t2(std::string(&quot;same?&quot;), 2, A());
-tuple&lt;std::string, long, A&gt; t3(std::string(&quot;different&quot;), 3, A());
-
-bool operator==(A, A) { std::cout &lt;&lt; &quot;All the same to me...&quot;; return true; }
-
-t1 == t2; 		// true
-t1 == t3;               // false, does not print &quot;All the...&quot;
-</code></pre>
-
-
-<h2><a name = "tiers">Tiers</a></h2>
-
-<p>
-<i>Tiers</i> are tuples, where all elements are of non-const reference types.
-They are constructed with a call to the <code>tie</code> function template (cf. <code>make_tuple</code>):
-
-<pre><code>int i; char c; double d; 
-  ...
-tie(i, c, a);
-</code></pre>
-
-<p>
-The above <code>tie</code> function creates a tuple of type <code>tuple&lt;int&amp;, char&amp;, double&amp;&gt;</code>. 
-The same result could be achieved with the call <code>make_tuple(ref(i), ref(c), ref(a))</code>.
-</p>
-
-<p>
-A tuple that contains non-const references as elements can be used to 'unpack' another tuple into variables. E.g.:
-
-<pre><code>int i; char c; double d; 
-tie(i, c, d) = make_tuple(1,'a', 5.5);
-std::cout &lt;&lt; i &lt;&lt; &quot; &quot; &lt;&lt;  c &lt;&lt; &quot; &quot; &lt;&lt; d;
-</code></pre>
-This code prints <code>1 a 5.5</code> to the standard output stream.
-
-A tuple unpacking operation like this is found for example in ML and Python. 
-It is convenient when calling functions which return tuples.
-
-<p>
-The tying mechanism works with <code>std::pair</code> templates as well:
-
-<pre><code>int i; char c;
-tie(i, c) = std::make_pair(1, 'a');
-</code></pre>
-<h4>Ignore</h4>
-There is also an object called <code>ignore</code> which allows you to ignore an element assigned by a tuple.
-The idea is that a function may return a tuple, only part of which you are interested in. For example (note, that <code>ignore</code> is under the <code>tuples</code> subnamespace):
-
-<pre><code>char c;
-tie(tuples::ignore, c) = std::make_pair(1, 'a');
-</code></pre>
-
-<h2><a name = "streaming">Streaming</a></h2>
-
-<p>
-The global <code>operator&lt;&lt;</code> has been overloaded for <code>std::ostream</code> such that tuples are 
-output by recursively calling <code>operator&lt;&lt;</code> for each element. 
-</p>
-
-<p>
-Analogously, the global <code>operator&gt;&gt;</code> has been overloaded to extract tuples from <code>std::istream</code>  by recursively calling <code>operator&gt;&gt;</code> for each element. 
-</p>
-
-<p>
-The default delimiter between the elements is space, and the tuple is enclosed
-in parenthesis.
-For Example:
-
-<pre><code>tuple&lt;float, int, std::string&gt; a(1.0f,  2, std::string(&quot;Howdy folks!&quot;);
-
-cout &lt;&lt; a; 
-</code></pre>
-outputs the tuple as: <code>(1.0 2 Howdy folks!)</code>
-
-<p>
-The library defines three <i>manipulators</i> for changing the default behavior:
-<ul>
-<li><code>set_open(char)</code> defines the character that is output before the first
-element.</li>
-<li><code>set_close(char)</code> defines the character that is output after the
-last element.</li>
-<li><code>set_delimiter(char)</code> defines the delimiter character between
-elements.</li>
-</ul>
-
-Note, that these manipulators are defined in the <code>tuples</code> subnamespace. 
-For example:
-<code><pre>cout &lt;&lt; tuples::set_open('[') &lt;&lt; tuples::set_close(']') &lt;&lt; tuples::set_delimiter(',') &lt;&lt; a; 
-</code></pre>
-outputs the same tuple <code>a</code> as: <code>[1.0,2,Howdy folks!]</code>
-
-<p>The same manipulators work with <code>operator&gt;&gt;</code> and <code>istream</code> as well. Suppose the <code>cin</code> stream contains the following data:
-
-<pre><code>(1 2 3) [4:5]</code></pre>
-
-The code:
-
-<code><pre>tuple&lt;int, int, int&gt; i;
-tuple&lt;int, int&gt; j;
-
-cin &gt;&gt; i;
-cin &gt;&gt; tuples::set_open('[') &gt;&gt; tuples::set_close(']') &gt;&gt; tules::set_delimiter(':');
-cin &gt;&gt; j;
-</code></pre>
-
-reads the data into the tuples <code>i</code> and <code>j</code>.
-
-<p>
-Note that extracting tuples with <code>std::string</code> or C-style string
-elements does not generally work, since the streamed tuple representation may not be unambiguously
-parseable.
-</p>
-
-<h2><a name = "performance">Performance</a></h2>
-
-All tuple access and construction functions are small inlined one-liners. 
-Therefore, a decent compiler can eliminate any extra cost of using tuples compared to using hand written tuple like classes. 
-Particularly, with a decent compiler there is no performance difference between this code:
-
-<pre><code>class hand_made_tuple { 
-  A a; B b; C c;
-public:
-  hand_made_tuple(const A&amp; aa, const B&amp; bb, const C&amp; cc) 
-    : a(aa), b(bb), c(cc) {};
-  A&amp; getA() { return a; };
-  B&amp; getB() { return b; };
-  C&amp; getC() { return c; };
-};
-
-hand_made_tuple hmt(A(), B(), C()); 
-hmt.getA(); hmt.getB(); hmt.getC();
-</code></pre>
-
-and this code:
-
-<pre><code>tuple&lt;A, B, C&gt; t(A(), B(), C());
-t.get&lt;0&gt;(); t.get&lt;1&gt;(); t.get&lt;2&gt;(); 
-</code></pre>
-
-<p>Note, that there are widely used compilers (e.g. bcc 5.5.1) which fail to optimize this kind of tuple usage.
-</p>  
-<p>
-Depending on the optimizing ability of the compiler, the tier mechanism may have a small performance penalty compared to using
-non-const reference parameters as a mechanism for returning multiple values from a function. 
-For example, suppose that the following functions <code>f1</code> and <code>f2</code> have equivalent functionalities:
-
-<pre><code>void f1(int&amp;, double&amp;);
-tuple&lt;int, double&gt; f2();
-</code></pre>
-
-Then, the call #1 may be slightly faster than #2 in the code below:
-
-<pre><code>int i; double d;
-  ...
-f1(i,d);         // #1
-tie(i,d) = f2(); // #2
-</code></pre>
-See 
-[<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>
-
-<p>
-Compiling tuples can be slow due to the excessive amount of template instantiations.
-Depending on the compiler and the tuple length, it may be more than 10 times slower to compile a tuple construct, compared to compiling an equivalent explicitly written class, such as the <code>hand_made_tuple</code> class above.
-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>]
-for details.
-</p>
-
-<h2><a name = "portability">Portability</a></h2>
-
-<p>The library code is(?) standard C++ and thus the library works with a standard conforming compiler. 
-Below is a list of compilers and known problems with each compiler:
-</p>
-<table>
-<tr><td><u>Compiler</u></td><td><u>Problems</u></td></tr>
-<tr><td>gcc 2.95</td><td>-</td></tr>
-<tr><td>edg 2.44</td><td>-</td></tr>
-<tr><td>Borland 5.5</td><td>Can't use function  pointers or member pointers as tuple elements</td></tr>
-<tr><td>Metrowerks 6.2</td><td>Can't use <code>ref</code> and <code>cref</code> wrappers</td></tr>
-<tr><td>MS Visual C++</td><td>No reference elements (<code>tie</code> still works). Can't use <code>ref</code> and <code>cref</code> wrappers</td></tr>
-</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. 
-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.
-<h2><a name = "references">References</a></h2>
-
-<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>)-->.
-</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>)-->.
-</p>
-
-<p>
-[3] J&auml;rvi J.:<i>Tuple Types and Multiple Return Values</i>, C/C++ Users Journal, August 2001.
-</p>
-
-<hr>
-
-<p>Last modified 2003-09-07</p>
-
-<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.
-</p>
-</body>
-</html>
-
-
-
-
--- 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
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// 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.

 // For more information, see http://www.boost.org

@ -13,18 +18,11 @@
 // 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,
-// William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes,
+// Several changes/additions according to suggestions by Doug Gregor, 
+// William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Davis,
 // 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
-//                    types, as long as no object is created.
-//                    Tuple objects can no hold even noncopyable types
-//                    such as arrays.
-// 2001 10 22 John Maddock
-//      Fixes for Borland C++
 // 2001 08 30 David Abrahams
 //      Added default constructor for cons<>.
 // ----------------------------------------------------------------- 
@ -36,9 +34,6 @@
 #include <utility> // needed for the assignment from pair to tuple

 #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 {
@ -48,18 +43,7 @@ struct null_type {};

 // a helper function to provide a const null_type type temporary
 namespace detail {
-  inline const null_type cnull() { return null_type(); }
-
-
-// -- if construct ------------------------------------------------
-// Proposed by Krzysztof Czarnecki and Ulrich Eisenecker
-
-template <bool If, class Then, class Else> struct IF { typedef Then RET; };
-
-template <class Then, class Else> struct IF<false, Then, Else> {
-  typedef Else RET;
-};
-
+  inline const null_type cnull_type() { return null_type(); }
 } // end detail

 // - cons forward declaration -----------------------------------------------
@ -86,6 +70,41 @@ namespace detail {
 template<class T>
 class generate_error;

+// tuple default argument wrappers ---------------------------------------
+// Work for non-reference types, intentionally not for references
+template <class T>
+struct default_arg {
+
+// Non-class temporaries cannot have qualifiers.
+// To prevent f to return for example const int, we remove cv-qualifiers
+// from all temporaries. 
+     static typename boost::remove_cv<T>::type f() { return T(); }
+};
+
+// This is just to produce a more informative error message
+// The code would fail in any case
+template<class T, int N>
+struct default_arg<T[N]> {
+  static T* f() { 
+    return generate_error<T[N]>::arrays_are_not_valid_tuple_elements; }
+};
+   
+template <class T>
+struct default_arg<T&> {
+  static T& f() { 
+#ifndef __sgi
+    return generate_error<T>::no_default_values_for_reference_types;
+#else
+    // MIPSpro instantiates functions even when it should not, so
+    // this technique can not be used for error checking.
+    // The simple workaround is to just not have this error checking
+    // with MIPSpro.
+    static T x;
+    return x;
+#endif
+  }
+};
+
 // - cons getters --------------------------------------------------------
 // called: get_class<N>::get<RETURN_TYPE>(aTuple)

@ -94,22 +113,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)
-    // 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
+    return get_class<N-1>::template get<RET>(t.tail);
  }
  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>::get<RET>(t.tail);
-#else
-    return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
-#endif
+    return get_class<N-1>::template get<RET>(t.tail);
  }
 };

@ -135,8 +144,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 +158,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)

@ -235,7 +172,6 @@ template <class T> struct access_traits {
  typedef T& non_const_type;

  typedef const typename boost::remove_cv<T>::type& parameter_type;
-
 // used as the tuple constructors parameter types
 // Rationale: non-reference tuple element types can be cv-qualified.
 // It should be possible to initialize such types with temporaries,
@ -251,24 +187,19 @@ template <class T> struct access_traits<T&> {
  typedef T& parameter_type;   
 };

+
 // get function for non-const cons-lists, returns a reference to the element

 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)) {
-#if BOOST_WORKAROUND(__IBMCPP__,==600 )
-  return detail::get_class<N>::
-#else
-  return detail::get_class<N>::BOOST_NESTED_TEMPLATE
-#endif
+get(cons<HT, TT>& c) { 
+  return detail::get_class<N>::template 
         get<
           typename access_traits<
             typename element<N, cons<HT, TT> >::type
-           >::non_const_type,
-           HT,TT
-         >(c);
+           >::non_const_type>(c); 
 } 

 // get function for const cons-lists, returns a const reference to
@ -278,43 +209,18 @@ 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)) {
-#if BOOST_WORKAROUND(__IBMCPP__,==600)
-  return detail::get_class<N>::
-#else
-  return detail::get_class<N>::BOOST_NESTED_TEMPLATE
-#endif
+get(const cons<HT, TT>& c) { 
+  return detail::get_class<N>::template 
         get<
           typename access_traits<
             typename element<N, cons<HT, TT> >::type
-           >::const_type,
-           HT,TT
-         >(c);
+         >::const_type>(c);
 } 

+
+
+
 // -- the cons template  --------------------------------------------------
-namespace detail {
-
-//  These helper templates wrap void types and plain function types.
-//  The reationale is to allow one to write tuple types with those types
-//  as elements, even though it is not possible to instantiate such object.
-//  E.g: typedef tuple<void> some_type; // ok
-//  but: some_type x; // fails
-
-template <class T> class non_storeable_type {
-  non_storeable_type();
-};
-
-template <class T> struct wrap_non_storeable_type {
-  typedef typename IF<
-    ::boost::is_function<T>::value, non_storeable_type<T>, T
-  >::RET type;
-};
-template <> struct wrap_non_storeable_type<void> {
-  typedef non_storeable_type<void> type;
-};
-
-} // detail

 template <class HT, class TT>
 struct cons {
@ -322,33 +228,28 @@ struct cons {
  typedef HT head_type;
  typedef TT tail_type;

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

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

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

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

-  cons() : head(), tail() {}
-  //  cons() : head(detail::default_arg<HT>::f()), 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, 
  // copy works only if the tails are exactly the same type, ...)
  
-  cons(typename access_traits<stored_head_type>::parameter_type h,
+  cons(typename access_traits<head_type>::parameter_type h,
       const tail_type& t)
    : head (h), tail(t) {}  

@ -357,18 +258,9 @@ struct cons {
  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())
+      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull_type())
      {}

-  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 (),
-      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
-      {}
-
-
  template <class HT2, class TT2>
  cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}

@ -395,7 +287,7 @@ struct cons {
             typename element<N, cons<HT, TT> >::type
           >::non_const_type
  get() {
-    return boost::tuples::get<N>(*this); // delegate to non-member get
+    return boost::get<N>(*this); // delegate to non-member get
  }

  template <int N>
@ -403,7 +295,7 @@ struct cons {
             typename element<N, cons<HT, TT> >::type
           >::const_type
  get() const {
-    return boost::tuples::get<N>(*this); // delegate to non-member get
+    return boost::get<N>(*this); // delegate to non-member get
  }
 };

@ -412,26 +304,22 @@ 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;
-  stored_head_type head;
+  head_type head;
 
-  typename access_traits<stored_head_type>::non_const_type
+  typename access_traits<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<head_type>::const_type 
  get_head() const { return head; }
  
  const null_type get_tail() const { return null_type(); }  

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

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

@ -441,12 +329,6 @@ struct cons<HT, null_type> {
       const null_type&, const null_type&, const null_type&)
  : head (t1) {}

-  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) {}
  
@ -460,18 +342,18 @@ 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)) {
-    return boost::tuples::get<N>(*this);
+  get() {
+    return boost::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 {
-    return boost::tuples::get<N>(*this);
+  get() const {
+    return boost::get<N>(*this);
  }

 };
@ -483,11 +365,6 @@ struct length  {
  BOOST_STATIC_CONSTANT(int, value = 1 + length<typename T::tail_type>::value);
 };

-template<>
-struct length<tuple<> > {
-  BOOST_STATIC_CONSTANT(int, value = 0);
-};
-
 template<>
 struct length<null_type> {
  BOOST_STATIC_CONSTANT(int, value = 0);
@ -532,96 +409,30 @@ public:


 // access_traits<T>::parameter_type takes non-reference types as const T& 
-  tuple() {}
+  explicit tuple(
+    typename access_traits<T0>::parameter_type t0 
+      = detail::default_arg<T0>::f(),
+    typename access_traits<T1>::parameter_type t1 
+      = detail::default_arg<T1>::f(),
+    typename access_traits<T2>::parameter_type t2 
+      = detail::default_arg<T2>::f(),
+    typename access_traits<T3>::parameter_type t3 
+      = detail::default_arg<T3>::f(),
+    typename access_traits<T4>::parameter_type t4 
+      = detail::default_arg<T4>::f(),
+    typename access_traits<T5>::parameter_type t5 
+      = detail::default_arg<T5>::f(),
+    typename access_traits<T6>::parameter_type t6 
+      = detail::default_arg<T6>::f(),
+    typename access_traits<T7>::parameter_type t7 
+      = detail::default_arg<T7>::f(),
+    typename access_traits<T8>::parameter_type t8 
+      = detail::default_arg<T8>::f(),
+    typename access_traits<T9>::parameter_type t9 
+      = detail::default_arg<T9>::f())

-  tuple(typename access_traits<T0>::parameter_type t0)
-    : 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(),
-                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(),
-                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(),
-                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,
-        typename access_traits<T4>::parameter_type t4)
-    : inherited(t0, t1, t2, t3, t4, 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,
-        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(),
-                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,
-        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(),
-                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,
-        typename access_traits<T4>::parameter_type t4,
-        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(),
-                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,
-        typename access_traits<T4>::parameter_type t4,
-        typename access_traits<T5>::parameter_type t5,
-        typename access_traits<T6>::parameter_type t6,
-        typename access_traits<T7>::parameter_type t7,
-        typename access_traits<T8>::parameter_type t8)
-    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, 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,
-        typename access_traits<T4>::parameter_type t4,
-        typename access_traits<T5>::parameter_type t5,
-        typename access_traits<T6>::parameter_type t6,
-        typename access_traits<T7>::parameter_type t7,
-        typename access_traits<T8>::parameter_type t8,
-        typename access_traits<T9>::parameter_type t9)
        : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}

-
  template<class U1, class U2>
  tuple(const cons<U1, U2>& p) : inherited(p) {}

@ -657,7 +468,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 +476,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
@ -784,54 +597,51 @@ inline tuple<> make_tuple() {
 template<class T0>
 inline typename detail::make_tuple_mapper<T0>::type
 make_tuple(const T0& t0) {
-  typedef typename detail::make_tuple_mapper<T0>::type t;
-  return t(t0);
+  return typename detail::make_tuple_mapper<T0>::type(t0); 
 }

 template<class T0, class T1>
 inline typename detail::make_tuple_mapper<T0, T1>::type
 make_tuple(const T0& t0, const T1& t1) {
-  typedef typename detail::make_tuple_mapper<T0, T1>::type t;
-  return t(t0, t1);
+  return typename detail::make_tuple_mapper<T0, T1>::type(t0, t1); 
 }

 template<class T0, class T1, class T2>
 inline typename detail::make_tuple_mapper<T0, T1, T2>::type
 make_tuple(const T0& t0, const T1& t1, const T2& t2) {
-  typedef typename detail::make_tuple_mapper<T0, T1, T2>::type t;
-  return t(t0, t1, t2);
+  return typename detail::make_tuple_mapper<T0, T1, T2>::type(t0, t1, t2); 
 }

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

 template<class T0, class T1, class T2, class T3, class T4>
 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 typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type
+           (t0, t1, t2, t3, t4); 
 }

 template<class T0, class T1, class T2, class T3, class T4, class T5>
 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 typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
+           (t0, t1, t2, t3, t4, t5); 
 }

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

 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
@ -839,9 +649,9 @@ template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
 inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
 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 typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7>::type
+           (t0, t1, t2, t3, t4, t5, t6, t7); 
 }

 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
@ -851,9 +661,9 @@ inline typename detail::make_tuple_mapper
 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,
                  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 typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
+           (t0, t1, t2, t3, t4, t5, t6, t7, t8); 
 }

 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
@ -863,9 +673,9 @@ inline typename detail::make_tuple_mapper
 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,
                  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 typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
+           (t0, t1, t2, t3, t4, t5, t6, t7, t8, t9); 
 }


--- 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
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// 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.

 // For more information, see http://www.boost.org or http://lambda.cs.utu.fi 

@ -48,25 +53,6 @@ namespace tuples {
    // 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 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
-    >
-    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 +77,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; }
-     tail_ref get_tail() { return tail; }
+     typename boost::add_reference<head_type>::type get_head() { return head; }
+     typename boost::add_reference<tail_type>::type 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>
-      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(),
-                    tail_cref t = tail_type()) :
+      explicit cons(const head_type& h = head_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)
@ -313,58 +231,6 @@ namespace tuples {

    namespace detail {

-#if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
-      // special workaround for vc7:
-
-      template <bool x>
-      struct reference_adder
-      {
-         template <class T>
-         struct rebind
-         {
-            typedef T& type;
-         };
-      };
-
-      template <>
-      struct reference_adder<true>
-      {
-         template <class T>
-         struct rebind
-         {
-            typedef T type;
-         };
-      };
-
-
-      // Return a reference to the Nth type of the given Tuple
-      template<int N, typename Tuple>
-      struct element_ref
-      {
-      private:
-         typedef typename element<N, Tuple>::RET elt_type;
-         enum { is_ref = is_reference<elt_type>::value };
-
-      public:
-         typedef reference_adder<is_ref>::rebind<elt_type>::type RET;
-         typedef RET type;
-      };
-
-      // Return a const reference to the Nth type of the given Tuple
-      template<int N, typename Tuple>
-      struct element_const_ref
-      {
-      private:
-         typedef typename element<N, Tuple>::RET elt_type;
-         enum { is_ref = is_reference<elt_type>::value };
-
-      public:
-         typedef reference_adder<is_ref>::rebind<const elt_type>::type RET;
-         typedef RET type;
-      };
-
-#else // vc7
-
      // Return a reference to the Nth type of the given Tuple
      template<int N, typename Tuple>
      struct element_ref
@ -388,7 +254,6 @@ namespace tuples {
        typedef typename add_reference<const elt_type>::type RET;
        typedef RET type;
      };
-#endif // vc7

    } // namespace detail

@ -399,10 +264,6 @@ namespace tuples {
      BOOST_STATIC_CONSTANT(int, value = 1 + length<typename Tuple::tail_type>::value);
    };

-    template<> struct length<tuple<> > {
-      BOOST_STATIC_CONSTANT(int, value = 0);
-    };
-
    template<>
    struct length<null_type>
    {
@ -457,15 +318,15 @@ namespace tuples {
    // tuple class
    template<
      typename T1, 
-      typename T2,
-      typename T3,
-      typename T4,
-      typename T5,
-      typename T6,
-      typename T7,
-      typename T8,
-      typename T9,
-      typename T10
+      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
    >
    class tuple : 
      public detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
@ -483,45 +344,25 @@ 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()))))))))))
-        {}
-
-      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()
-      ) :
+      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()) :
        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)
      {
      }
@ -734,8 +575,8 @@ namespace tuples {
                        detail::assign_to_pointee<T2>(&t2),
                        detail::assign_to_pointee<T3>(&t3),
                        detail::assign_to_pointee<T4>(&t4),
-                        detail::assign_to_pointee<T5>(&t5),
-                        detail::assign_to_pointee<T6>(&t6));
+                        detail::assign_to_pointee<T6>(&t5),
+                        detail::assign_to_pointee<T5>(&t6));
    }

    // Tie variables into a tuple
@ -833,8 +674,9 @@ namespace tuples {
                        detail::assign_to_pointee<T10>(&t10));
    }
    // "ignore" allows tuple positions to be ignored when using "tie". 
-
-detail::swallow_assign const ignore = detail::swallow_assign();
+    namespace {
+      detail::swallow_assign ignore;
+    }

 } // namespace tuples
 } // namespace boost
--- a/include/boost/tuple/reference_wrappers.hpp
+++ b/include/boost/tuple/reference_wrappers.hpp
@ -0,0 +1,57 @@
+// -- reference_wrappers - Boost Tuple Library -----------------------------
+
+// Copyright (C) 1999, 2000 Jaakko J<>rvi (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.
+//
+// For more information, see http://www.boost.org 
+
+// ----------------------------------------------------------------- 
+
+#ifndef BOOST_TUPLE_REFERENCE_WRAPPERS_HPP
+#define BOOST_TUPLE_REFERENCE_WRAPPERS_HPP
+
+namespace boost {
+
+
+// reference wrappers -------------------------------------------------------
+  
+// These wrappers are handle classes that hold references to objects.
+
+// reference_wrapper is used to specify that a tuple element should be 
+// a reference to the wrapped object - rather than a copy of it.
+// The wrapper acts as a disguise for passing non-const reference 
+// parameters via a reference to const parameter.
+
+template<class T>
+class reference_wrapper { 
+  T& x; 
+public:
+  explicit 
+  reference_wrapper(T& t) : x(t) {} 
+  operator T&() const { return x; }
+};
+
+// store as a reference to T
+template<class T> 
+inline const reference_wrapper<T> ref(T& t) { 
+  return reference_wrapper<T>(t); 
+}
+
+// store as a reference to const T
+template<class T> 
+inline const reference_wrapper<const T> cref(const T& t) {
+  return reference_wrapper<const T>(t); 
+}
+   
+} // end of namespace boost
+
+
+#endif	// BOOST_TUPLE_REFERENCE_WRAPPERS_HPP
--- 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
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// 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.

 // 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"

@ -29,7 +27,7 @@ namespace boost { namespace python { class tuple; }}

 #else
 // other compilers
-#include "boost/ref.hpp"
+#include "boost/tuple/reference_wrappers.hpp"
 #include "boost/tuple/detail/tuple_basic.hpp"

 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
@ -39,50 +37,7 @@ namespace boost {
 using tuples::tuple;
 using tuples::make_tuple;
 using tuples::tie;
-#if !defined(BOOST_NO_USING_TEMPLATE)
 using tuples::get;
-#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-//
-// The "using tuples::get" statement causes the
-// Borland compiler to ICE, use forwarding
-// functions instead:
-//
-template<int N, class HT, class TT>
-inline typename tuples::access_traits<
-                  typename tuples::element<N, tuples::cons<HT, TT> >::type
-                >::non_const_type
-get(tuples::cons<HT, TT>& c) {
-  return tuples::get<N,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
-// as such (that is, can return a non-const reference)
-template<int N, class HT, class TT>
-inline typename tuples::access_traits<
-                  typename tuples::element<N, tuples::cons<HT, TT> >::type
-                >::const_type
-get(const tuples::cons<HT, TT>& c) {
-  return tuples::get<N,HT,TT>(c);
-}
-#else  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-//
-// MSVC, using declarations don't mix with templates well,
-// so use forwarding functions instead:
-//
-template<int N, typename Head, typename Tail>
-typename tuples::detail::element_ref<N, tuples::cons<Head, Tail> >::RET
-get(tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0)
-{
-   return tuples::detail::get_class<N>::get(t);
-}
-
-template<int N, typename Head, typename Tail>
-typename tuples::detail::element_const_ref<N, tuples::cons<Head, Tail> >::RET
-get(const tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0)
-{
-   return tuples::detail::get_class<N>::get(t);
-}
-#endif // BOOST_NO_USING_TEMPLATE
   
 } // end namespace boost

--- 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
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// 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.
 // 
 // For more information, see http://www.boost.org
 // 
@ -64,7 +69,7 @@ inline bool neq(const T1& lhs, const T2& rhs) {
         neq(lhs.get_tail(), rhs.get_tail());
 }
 template<>
-inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return false; }
+inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return true; }

 template<class T1, class T2>
 inline bool lt(const T1& lhs, const T2& rhs) {
--- 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
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// 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.
 // For more information, see http://www.boost.org 

 // ----------------------------------------------------------------------------
@ -31,22 +36,7 @@

 #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 {
@ -55,19 +45,11 @@ namespace detail {

 class format_info {
 public:   
-
   enum manipulator_type { open, close, delimiter };
   BOOST_STATIC_CONSTANT(int, number_of_manipulators = delimiter + 1);
 private:
   
-   static int get_stream_index (int m)
-   {
-     static const int stream_index[number_of_manipulators]
-        = { std::ios::xalloc(), std::ios::xalloc(), std::ios::xalloc() };
-
-     return stream_index[m];
-   }
-
+   static const int stream_index[number_of_manipulators];
   format_info(const format_info&);
   format_info();   

@ -76,21 +58,21 @@ public:

 #if defined (BOOST_NO_TEMPLATED_STREAMS)
   static char get_manipulator(std::ios& i, manipulator_type m) {
-     char c = static_cast<char>(i.iword(get_stream_index(m))); 
+     char c = static_cast<char>(i.iword(stream_index[m])); 
     
     // parentheses and space are the default manipulators
     if (!c) {
       switch(m) {
-         case detail::format_info::open : c = '('; break;
-         case detail::format_info::close : c = ')'; break;
-         case detail::format_info::delimiter : c = ' '; break;
+         case open : c = '('; break;					    
+         case close : c = ')'; break;					    
+         case delimiter : c = ' '; break;
       }
     }
     return c;
   }

   static void set_manipulator(std::ios& i, manipulator_type m, char c) {
-      i.iword(get_stream_index(m)) = static_cast<long>(c);
+      i.iword(stream_index[m]) = static_cast<long>(c);
   }
 #else
   template<class CharType, class CharTrait>
@ -100,13 +82,13 @@ public:
     // A valid instanitation of basic_stream allows CharType to be any POD,
     // hence, the static_cast may fail (it fails if long is not convertible 
     // to CharType
-     CharType c = static_cast<CharType>(i.iword(get_stream_index(m)) ); 
+     CharType c = static_cast<CharType>(i.iword(stream_index[m]) ); 
     // parentheses and space are the default manipulators
     if (!c) {
       switch(m) {
-         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;
+         case open :  c = i.widen('('); break;					    
+         case close : c = i.widen(')'); break;					    
+         case delimiter : c = i.widen(' '); break;
       }
     }
     return c;
@ -120,7 +102,7 @@ public:
     // A valid instanitation of basic_stream allows CharType to be any POD,
     // hence, the static_cast may fail (it fails if CharType is not 
     // convertible long.
-      i.iword(get_stream_index(m)) = static_cast<long>(c);
+      i.iword(stream_index[m]) = static_cast<long>(c);
   }
 #endif	// BOOST_NO_TEMPLATED_STREAMS
 };
@ -340,16 +322,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);
-#else
-  const bool is_delimiter = (!std::isspace(d, is.getloc()) );            
-#endif
+  const bool is_delimiter = (!isspace(d) );      

  char c;
  if (is_delimiter) { 
    is >> c; 
-    if (is.good() && c!=d) {
+    if (c!=d) {
      is.setstate(std::ios::failbit);
    } 
  }
@ -431,19 +409,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);
-#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
+  const bool is_delimiter = (!isspace(d) );      

  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/src/tuple.cpp
+++ b/src/tuple.cpp
@ -0,0 +1,34 @@
+//  tuple.cpp -----------------------------------------------------
+
+// Copyright (C) 1999, 2000, 2001 Jaakko J<>rvi (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.
+
+// For more information, see http://lambda.cs.utu.fi 
+
+// Revision History 
+
+// 16 02 01 Initial Version (GWP)
+// ----------------------------------------------------------------- 
+
+#include "boost/tuple/tuple_io.hpp"
+
+namespace boost {
+namespace tuples {
+namespace detail {
+   
+const int
+ format_info::stream_index[number_of_manipulators] 
+   = { std::ios::xalloc(), std::ios::xalloc(), std::ios::xalloc() };
+   
+} // namespace detail
+} // namespace tuples   
+} // namespace boost
--- 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/README
+++ b/test/README
@ -8,9 +8,7 @@ For example, in libs/tuple/test directory you would type (using g++):

 g++ -I../../.. tuple_test_bench.cpp

-The following is not true anymore:
+If you want to use tuple_io, you need to compile and link src/tuple.cpp:

-  If you want to use tuple_io, you need to compile and link src/tuple.cpp:
-  g++ -I../../.. ../src/tuple.cpp io_test.cpp
+g++ -I../../.. ../src/tuple.cpp io_test.cpp

-Thanks to Hartmut Kaiser's suggestion, the tuple.cpp is not needed anymore.
--- 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
@ -74,8 +65,9 @@ void foo2() {
  dummy(tuple<const double&>()); // likewise
 #endif

-#ifdef E5
  double dd = 5;
+
+#ifdef E5
  dummy(tuple<double&>(dd+3.14)); // should fail, temporary to non-const reference
 #endif
 }
@ -98,11 +90,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 +106,8 @@ void foo4()
 #ifdef E10
  dummy(get<5>(ct)); // illegal index
 #endif
+
+#endif
 }

 // testing copy and assignment with implicit conversions between elements
@ -125,10 +120,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_CHECK(ti == make_tuple(100, 200, 300));
+  BOOST_TEST(is >> ti);
+  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>

@ -35,7 +24,7 @@ class C {};
 // classes with different kinds of conversions
 class AA {};
 class BB : public AA {}; 
-struct CC { CC() {} CC(const BB&) {} };
+struct CC { CC() {} CC(const BB& b) {} };
 struct DD { operator CC() const { return CC(); }; };

 // something to prevent warnings for unused variables
@ -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(tuples::get<0>(t1) == int());
  
  tuple<float> t2(5.5f);
-  BOOST_CHECK(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f);
+  BOOST_TEST(tuples::get<0>(t2) > 5.4f && tuples::get<0>(t2) < 5.6f);

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

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

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

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

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

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

  dummy( 
    tuple<no_def_constructor, no_def_constructor, no_def_constructor>(
@ -151,13 +147,16 @@ 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,48 +166,35 @@ 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);
-  const tuple<int, double&, const A, int> ct = t;
+  tuple<int, double&, const A&> t(1, d, a);
+  const tuple<int, double&, const A> ct = t;

-  int i  = get<0>(t);
-  int i2 = get<3>(t);
+  int i = tuples::get<0>(t);
+  int j = tuples::get<0>(ct);
+  BOOST_TEST(i == 1 && j == 1);
   
-  BOOST_CHECK(i == 1 && i2 == 2);
+  tuples::get<0>(t) = 5;
+  BOOST_TEST(t.head == 5);
   
-  int j  = get<0>(ct);
-  BOOST_CHECK(j == 1);
+  //  tuples::get<0>(ct) = 5; // can't assign to const

-  get<0>(t) = 5;
-  BOOST_CHECK(t.head == 5);
+  double e = tuples::get<1>(t);
+  BOOST_TEST(e > 2.69 && e < 2.71);
 	     
-  //  get<0>(ct) = 5; // can't assign to const
+  tuples::get<1>(t) = 3.14+i;
+  BOOST_TEST(tuples::get<1>(t) > 4.13 && tuples::get<1>(t) < 4.15);

-  double e = get<1>(t);
-  BOOST_CHECK(e > 2.69 && e < 2.71);
+  //  tuples::get<4>(t) = A(); // can't assign to const
+  //  dummy(tuples::get<5>(ct)); // illegal index

-  get<1>(t) = 3.14+i;
-  BOOST_CHECK(get<1>(t) > 4.13 && get<1>(t) < 4.15);
+  ++tuples::get<0>(t);
+  BOOST_TEST(tuples::get<0>(t) == 6);

-  //  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_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));
+  dummy(i); dummy(j); dummy(e); // avoid warns for unused variables
 #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
 }


@ -224,13 +210,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_CHECK(get<1>(t1) == get<1>(t2));
+  BOOST_TEST(tuples::get<0>(t1) == tuples::get<0>(t2));
+  BOOST_TEST(tuples::get<1>(t1) == tuples::get<1>(t2));

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

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

 void
 mutate_test()
 {
  tuple<int, float, bool, foo> t1(5, 12.2f, true, foo(4));
-  get<0>(t1) = 6;
-  get<1>(t1) = 2.2f;
-  get<2>(t1) = false;
-  get<3>(t1) = foo(5);
+  tuples::get<0>(t1) = 6;
+  tuples::get<1>(t1) = 2.2f;
+  tuples::get<2>(t1) = false;
+  tuples::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));
+  BOOST_TEST(tuples::get<0>(t1) == 6);
+  BOOST_TEST(tuples::get<1>(t1) > 2.1f && tuples::get<1>(t1) < 2.3f);
+  BOOST_TEST(tuples::get<2>(t1) == false);
+  BOOST_TEST(tuples::get<3>(t1) == foo(5));
 }

 // ----------------------------------------------------------------------------
@ -270,36 +256,40 @@ void
 make_tuple_test()
 {
  tuple<int, char> t1 = make_tuple(5, 'a');
-  BOOST_CHECK(get<0>(t1) == 5);
-  BOOST_CHECK(get<1>(t1) == 'a');
+  BOOST_TEST(tuples::get<0>(t1) == 5);
+  BOOST_TEST(tuples::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_CHECK(get<1>(t2) == "Hi");
+  BOOST_TEST(tuples::get<0>(t2) == 2);
+  BOOST_TEST(tuples::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(boost::ref(a), b);
-    make_tuple(boost::ref(a), boost::cref(b));
+    make_tuple(cref(a), b);
+    make_tuple(ref(a), 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 +326,19 @@ tie_test()
  foo c(5);

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

  tie(a, tuples::ignore, c) = make_tuple((short int)5, false, foo(5));
-  BOOST_CHECK(a == 5);
-  BOOST_CHECK(b == 'a');
-  BOOST_CHECK(c == foo(5));
+  BOOST_TEST(a == 5);
+  BOOST_TEST(b == 'a');
+  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 +358,12 @@ 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_CHECK(t1 != t4);
-  BOOST_CHECK(!(t1 != t2));
+  BOOST_TEST(t1 != t3);
+  BOOST_TEST(t1 != t4);
 }


@ -388,14 +377,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_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);
+  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);

 }

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

@ -412,10 +402,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,30 +415,10 @@ void cons_test()
 void const_tuple_test()
 {
  const tuple<int, float> t1(5, 3.3f);
-  BOOST_CHECK(get<0>(t1) == 5);
-  BOOST_CHECK(get<1>(t1) == 3.3f);
+  BOOST_TEST(tuples::get<0>(t1) == 5);
+  BOOST_TEST(tuples::get<1>(t1) == 3.3f);
 }

-// ----------------------------------------------------------------------------
-// - testing length -----------------------------------------------------------
-// ----------------------------------------------------------------------------
-void tuple_length_test()
-{
-  typedef tuple<int, float, double> t1;
-  using tuples::cons;
-  typedef cons<int, cons< float, cons <double, tuples::null_type> > > t1_cons;
-  typedef tuple<> t2;
-  typedef tuples::null_type t3;  
-
-  BOOST_STATIC_ASSERT(tuples::length<t1>::value == 3);
-  BOOST_STATIC_ASSERT(tuples::length<t1_cons>::value == 3);
-  BOOST_STATIC_ASSERT(tuples::length<t2>::value == 0);
-  BOOST_STATIC_ASSERT(tuples::length<t3>::value == 0);
-
-}
-
-
-

 // ----------------------------------------------------------------------------
 // - main ---------------------------------------------------------------------
@ -465,13 +436,5 @@ int test_main(int, char *[]) {
  ordering_test();
  cons_test();
  const_tuple_test();
-  tuple_length_test();
  return 0;
 }
-
-
-
-
-
-
-
Author	SHA1	Message	Date
Jaakko Järvi	2d62dc5f16	moved some tests that require user interaction from tuple_test_bench.cpp to another_tuple_test_bench.cpp [SVN r11059]	2001-09-07 11:04:50 +00:00
Jaakko Järvi	2a2632a159	tuples in separate namespaces now compile under MSVC++ as well changed tuple_length, tuple_element, tuple_access_traits to tuples::length, tuples::element and tuples::access_traits [SVN r11058]	2001-09-07 11:02:01 +00:00
Douglas Gregor	b8cca277e5	Now works on non-MSVC compilers [SVN r11057]	2001-09-06 22:25:15 +00:00
Jaakko Järvi	c10fd424bc	Definitions now in tuples subnamespace [SVN r11052]	2001-09-06 13:51:22 +00:00
Jaakko Järvi	984cbdc728	tuples subnamespace added [SVN r11051]	2001-09-06 13:50:27 +00:00
Jaakko Järvi	09a730c9bc	most definitions are now in tuples subnamespace, more tests moved to tuple_test_bench.cpp [SVN r11050]	2001-09-06 13:49:31 +00:00
nobody	43ea26d05e	This commit was manufactured by cvs2svn to create branch 'tuples_subnamespace'. [SVN r11026]	2001-09-05 03:22:32 +00:00