This commit was manufactured by cvs2svn to create branch

'python-v2-dev'. [SVN r14785]
Fixed a dumb typo (thanks Marsh)
2025-06-26 04:22:25 +02:00 · 2002-08-12 13:35:54 +00:00 · 2002-06-24 14:20:29 +00:00 · 2002-06-06 15:47:23 +00:00 · 2002-06-06 15:44:51 +00:00 · 2002-05-09 17:26:37 +00:00
14 changed files with 1321 additions and 301 deletions
--- a/doc/design_decisions_rationale.html
+++ b/doc/design_decisions_rationale.html
@ -0,0 +1,153 @@
+<html>
+
+<title>Design decisions rationale for Boost Tuple Library</title>
+
+<body bgcolor="#FFFFFF" text="#000000">
+
+<IMG SRC="../../../c++boost.gif" 
+     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
@ -0,0 +1,133 @@
+<!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="../../../c++boost.gif" 
+     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>.
+</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;::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
@ -0,0 +1,529 @@
+<html>
+<head>
+<title>The Boost Tuple Library</title>
+</head>
+<body bgcolor="#FFFFFF" text="#000000">
+
+<IMG SRC="../../../c++boost.gif" 
+     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;)[5], const char (&amp;)[6]&gt;</code> 
+(note that the type of a string literal is an array of const characters, not <code>const char*</code>). 
+However, to get <code>make_tuple</code> to create a tuple with an element of a
+non-const array type one must use the <code>ref</code> wrapper.
+
+<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. 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 2001-09-13</p>
+
+<p>&copy; Copyright <a href="../../../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
@ -23,6 +23,13 @@
 // 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<>.
 // ----------------------------------------------------------------- 
@ -34,7 +41,8 @@
 #include <utility> // needed for the assignment from pair to tuple

 #include "boost/type_traits/cv_traits.hpp"
-							    
+#include "boost/type_traits/function_traits.hpp"
+    
 namespace boost {
 namespace tuples {

@ -43,7 +51,18 @@ struct null_type {};

 // a helper function to provide a const null_type type temporary
 namespace detail {
-  inline const null_type cnull_type() { return null_type(); }
+  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;
+};
+
 } // end detail

 // - cons forward declaration -----------------------------------------------
@ -65,46 +84,22 @@ template<class T> struct length;

 namespace detail {

+#ifdef BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
+
+  template<int N> struct workaround_holder {};
+
+#  define BOOST_TUPLE_DUMMY_PARM        , detail::workaround_holder<N>* = 0
+#  define BOOST_TUPLE_SINGLE_DUMMY_PARM detail::workaround_holder<N>* = 0
+#else
+#  define BOOST_TUPLE_DUMMY_PARM
+#  define BOOST_TUPLE_SINGLE_DUMMY_PARM
+#endif
+
 // -- generate error template, referencing to non-existing members of this 
 // template is used to produce compilation errors intentionally
 template<class T>
 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)

@ -172,6 +167,7 @@ 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,
@ -187,14 +183,13 @@ 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) { 
+get(cons<HT, TT>& c BOOST_TUPLE_DUMMY_PARM) { 
  return detail::get_class<N>::template 
         get<
           typename access_traits<
@ -209,7 +204,7 @@ 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) { 
+get(const cons<HT, TT>& c BOOST_TUPLE_DUMMY_PARM) { 
  return detail::get_class<N>::template 
         get<
           typename access_traits<
@ -217,10 +212,29 @@ get(const cons<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 {
@ -228,28 +242,33 @@ struct cons {
  typedef HT head_type;
  typedef TT tail_type;

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

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

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

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

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

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

+  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) {}

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

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

@ -305,21 +333,24 @@ struct cons<HT, null_type> {
  typedef HT head_type;
  typedef null_type tail_type;

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

-  typename access_traits<head_type>::const_type 
+  typename access_traits<stored_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(detail::default_arg<HT>::f()) {}
+  cons() : head() {}

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

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

+  cons(const null_type& t1, 
+       const null_type&, const null_type&, const null_type&, 
+       const null_type&, const null_type&, const null_type&, 
+       const null_type&, const null_type&, const null_type&)
+  : head () {}
+
  template <class HT2>
  cons( const cons<HT2, null_type>& u ) : head(u.head) {}
  
@ -344,16 +381,16 @@ struct cons<HT, null_type> {
  typename access_traits<
             typename element<N, cons>::type
            >::non_const_type
-  get() {
-    return boost::get<N>(*this);
+  get(BOOST_TUPLE_SINGLE_DUMMY_PARM) {
+    return boost::tuples::get<N>(*this);
  }

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

 };
@ -365,6 +402,11 @@ 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);
@ -409,29 +451,95 @@ public:


 // access_traits<T>::parameter_type takes non-reference types as const T& 
-  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() {}
+  
+  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) {}

-        : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}

  template<class U1, class U2>
  tuple(const cons<U1, U2>& p) : inherited(p) {}
@ -597,51 +705,54 @@ inline tuple<> make_tuple() {
 template<class T0>
 inline typename detail::make_tuple_mapper<T0>::type
 make_tuple(const T0& t0) {
-  return typename detail::make_tuple_mapper<T0>::type(t0); 
+  typedef typename detail::make_tuple_mapper<T0>::type t;
+  return t(t0);
 }

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

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

 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
@ -661,9 +772,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) {
-  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); 
+  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); 
 }

 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
@ -673,9 +784,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) {
-  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); 
+  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); 
 }


@ -748,7 +859,9 @@ tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
 } // end of namespace tuples
 } // end of namespace boost

+#undef BOOST_TUPLE_DUMMY_PARM
+#undef BOOST_TUPLE_SINGLE_DUMMY_PARM

-#endif	// BOOST_TUPLE_BASIC_HPP
+#endif // BOOST_TUPLE_BASIC_HPP


--- a/include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp
+++ b/include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp
@ -53,6 +53,21 @@ 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;
+
    namespace detail {

      // Takes a pointer and routes all assignments to whatever it points to
@ -231,6 +246,58 @@ 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
@ -254,6 +321,7 @@ namespace tuples {
        typedef typename add_reference<const elt_type>::type RET;
        typedef RET type;
      };
+#endif // vc7

    } // namespace detail

@ -263,6 +331,10 @@ 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>
@ -318,15 +390,15 @@ namespace tuples {
    // tuple class
    template<
      typename T1, 
-      typename T2 = null_type, 
-      typename T3 = null_type, 
-      typename T4 = null_type,
-      typename T5 = null_type,
-      typename T6 = null_type,
-      typename T7 = null_type,
-      typename T8 = null_type,
-      typename T9 = null_type,
-      typename T10 = null_type
+      typename T2, 
+      typename T3, 
+      typename T4,
+      typename T5,
+      typename T6,
+      typename T7,
+      typename T8,
+      typename T9,
+      typename T10
    >
    class tuple : 
      public detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
@ -345,6 +417,7 @@ namespace tuples {
      typedef typename mapped_tuple::cons1 cons1;

    public:
+      typedef cons1 inherited;
      typedef tuple self_type;

      explicit tuple(const T1& t1 = T1(), 
@ -575,8 +648,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<T6>(&t5),
-                        detail::assign_to_pointee<T5>(&t6));
+                        detail::assign_to_pointee<T5>(&t5),
+                        detail::assign_to_pointee<T6>(&t6));
    }

    // Tie variables into a tuple
--- a/include/boost/tuple/reference_wrappers.hpp
+++ b/include/boost/tuple/reference_wrappers.hpp
@ -1,57 +0,0 @@
-// -- 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
@ -27,19 +27,62 @@

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

 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

-namespace boost {				    
+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


-#endif	// BOOST_TUPLE_HPP
+#endif // BOOST_TUPLE_HPP
--- a/include/boost/tuple/tuple_comparison.hpp
+++ b/include/boost/tuple/tuple_comparison.hpp
@ -69,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 true; }
+inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return false; }

 template<class T1, class T2>
 inline bool lt(const T1& lhs, const T2& rhs) {
@ -177,4 +177,4 @@ inline bool operator>=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
 } // end of namespace boost


-#endif	// BOOST_TUPLE_COMPARISON_HPP
+#endif // BOOST_TUPLE_COMPARISON_HPP
--- a/include/boost/tuple/tuple_io.hpp
+++ b/include/boost/tuple/tuple_io.hpp
@ -25,7 +25,7 @@
 #   if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97) 
 #define BOOST_NO_TEMPLATED_STREAMS
 #endif
-#endif	// __GNUC__
+#endif // __GNUC__

 #if defined BOOST_NO_TEMPLATED_STREAMS
 #include <iostream>
@ -36,8 +36,6 @@

 #include "boost/tuple/tuple.hpp"

-
-				    
 namespace boost {
 namespace tuples {

@ -45,11 +43,19 @@ namespace detail {

 class format_info {
 public:   
+
   enum manipulator_type { open, close, delimiter };
   BOOST_STATIC_CONSTANT(int, number_of_manipulators = delimiter + 1);
 private:
   
-   static const int stream_index[number_of_manipulators];
+   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];
+   }
+
   format_info(const format_info&);
   format_info();   

@ -58,13 +64,13 @@ public:

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

   static void set_manipulator(std::ios& i, manipulator_type m, char c) {
-      i.iword(stream_index[m]) = static_cast<long>(c);
+      i.iword(get_stream_index(m)) = static_cast<long>(c);
   }
 #else
   template<class CharType, class CharTrait>
@ -82,12 +88,12 @@ 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(stream_index[m]) ); 
+     CharType c = static_cast<CharType>(i.iword(get_stream_index(m)) ); 
     // parentheses and space are the default manipulators
     if (!c) {
       switch(m) {
-         case open :  c = i.widen('('); break;					    
-         case close : c = i.widen(')'); break;					    
+         case open :  c = i.widen('('); break;
+         case close : c = i.widen(')'); break;
         case delimiter : c = i.widen(' '); break;
       }
     }
@ -102,9 +108,9 @@ 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(stream_index[m]) = static_cast<long>(c);
+      i.iword(get_stream_index(m)) = static_cast<long>(c);
   }
-#endif	// BOOST_NO_TEMPLATED_STREAMS
+#endif // BOOST_NO_TEMPLATED_STREAMS
 };

 } // end of namespace detail
@ -133,8 +139,8 @@ public:
  void set(std::basic_ios<CharType, CharTrait> &io) const {
     detail::format_info::set_manipulator(io, mt, f_c);
  }
-#endif	// BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#endif	// BOOST_NO_TEMPLATED_STREAMS
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif // BOOST_NO_TEMPLATED_STREAMS
 };

 #if defined (BOOST_NO_TEMPLATED_STREAMS)
@ -204,7 +210,7 @@ template<class T1>
 inline std::ostream& print(std::ostream& o, const cons<T1, null_type>& t) {
  return o << t.head;
 }
-#endif	// BOOST_NO_TEMPLATED_STREAMS
+#endif // BOOST_NO_TEMPLATED_STREAMS
 
 inline std::ostream& print(std::ostream& o, const null_type&) { return o; }

@ -218,7 +224,7 @@ print(std::ostream& o, const cons<T1, T2>& t) {

 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  if (tuples::length<T2>::value == 0)
-	return o;
+    return o;
 #endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
  o << d;
  
@ -255,14 +261,14 @@ print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, T2>& t) {

 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  if (tuples::length<T2>::value == 0)
-	return o;
+    return o;
 #endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
  o << d;

  return print(o, t.tail);
 }

-#endif	// BOOST_NO_TEMPLATED_STREAMS
+#endif  // BOOST_NO_TEMPLATED_STREAMS

 } // namespace detail

@ -306,7 +312,7 @@ operator<<(std::basic_ostream<CharType, CharTrait>& o,

  return o;
 }
-#endif	// BOOST_NO_TEMPLATED_STREAMS
+#endif // BOOST_NO_TEMPLATED_STREAMS

   
 // -------------------------------------------------------------
@ -349,7 +355,7 @@ read (std::istream &is, cons<T1, null_type>& t1) {
 }
 #else
 inline std::istream& read(std::istream& i, const null_type&) { return i; }
-#endif	// !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   
 template<class T1, class T2>
 inline std::istream& 
@ -361,7 +367,7 @@ read(std::istream &is, cons<T1, T2>& t1) {

 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  if (tuples::length<T2>::value == 0)
-	return is;
+    return is;
 #endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

  extract_and_check_delimiter(is, format_info::delimiter);
@ -436,7 +442,7 @@ template<class CharType, class CharTrait>
 inline std::basic_istream<CharType, CharTrait>& 
 read(std::basic_istream<CharType, CharTrait>& i, const null_type&) { return i; }

-#endif	// !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

 template<class CharType, class CharTrait, class T1, class T2>
 inline std::basic_istream<CharType, CharTrait>& 
@ -448,7 +454,7 @@ read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) {

 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  if (tuples::length<T2>::value == 0)
-	return is;
+    return is;
 #endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

  extract_and_check_delimiter(is, format_info::delimiter);
@ -486,11 +492,11 @@ operator>>(std::basic_istream<CharType, CharTrait>& is, cons<T1, T2>& t1) {
  return is;
 }

-#endif	// BOOST_NO_TEMPLATED_STREAMS
+#endif // BOOST_NO_TEMPLATED_STREAMS

 } // end of namespace tuples
 } // end of namespace boost

-#endif	// BOOST_TUPLE_IO_HPP
+#endif // BOOST_TUPLE_IO_HPP


--- a/src/tuple.cpp
+++ b/src/tuple.cpp
@ -1,34 +0,0 @@
-//  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/README
+++ b/test/README
@ -8,7 +8,9 @@ For example, in libs/tuple/test directory you would type (using g++):

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

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

-g++ -I../../.. ../src/tuple.cpp io_test.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

+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
@ -65,9 +65,8 @@ void foo2() {
  dummy(tuple<const double&>()); // likewise
 #endif

-  double dd = 5;
-
 #ifdef E5
+  double dd = 5;
  dummy(tuple<double&>(dd+3.14)); // should fail, temporary to non-const reference
 #endif
 }
--- a/test/io_test.cpp
+++ b/test/io_test.cpp
@ -75,7 +75,7 @@ int test_main(int argc, char * argv[] ) {
  
  // When teading tuples from a stream, manipulators must be set correctly:
  ifstream tmp3("temp.tmp");
-  tuple<string, string, int> j;		    
+  tuple<string, string, int> j;

 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  tmp3 >> j; 
--- a/test/tuple_test_bench.cpp
+++ b/test/tuple_test_bench.cpp
@ -24,7 +24,7 @@ class C {};
 // classes with different kinds of conversions
 class AA {};
 class BB : public AA {}; 
-struct CC { CC() {} CC(const BB& b) {} };
+struct CC { CC() {} CC(const BB&) {} };
 struct DD { operator CC() const { return CC(); }; };

 // something to prevent warnings for unused variables
@ -97,42 +97,42 @@ tuple<char(&)[10]> v2(cs);  // ok
 void
 construction_test()
 {
- 
+
  // Note, the get function can be called without the tuples:: qualifier,
  // as it is lifted to namespace boost with a "using tuples::get" but
  // MSVC 6.0 just cannot find get without the namespace qualifier

-  tuple<int> t1; 
-  BOOST_TEST(tuples::get<0>(t1) == int());
-  
+  tuple<int> t1;
+  BOOST_TEST(get<0>(t1) == int());
+
  tuple<float> t2(5.5f);
-  BOOST_TEST(tuples::get<0>(t2) > 5.4f && tuples::get<0>(t2) < 5.6f);
+  BOOST_TEST(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f);

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

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

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

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

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

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

-  dummy( 
+  dummy(
    tuple<no_def_constructor, no_def_constructor, no_def_constructor>(
-       std::string("Jaba"),   // ok, since the default 
+       std::string("Jaba"),   // ok, since the default
       std::string("Daba"),   // constructor is not used
       std::string("Doo")
    )
@ -141,7 +141,7 @@ construction_test()
 // testing default values
  dummy(tuple<int, double>());
  dummy(tuple<int, double>(1));
-  dummy(tuple<int, double>(1,3.14)); 
+  dummy(tuple<int, double>(1,3.14));


  //  dummy(tuple<double&>()); // should fail, not defaults for references
@ -154,9 +154,8 @@ construction_test()
  dummy(tuple<const double&>(dd+3.14)); // ok, but dangerous
 #endif

-  //  dummy(tuple<double&>(dd+3.14)); // should fail, 
+  //  dummy(tuple<double&>(dd+3.14)); // should fail,
  //                                  // temporary to non-const reference
-
 }


@ -164,36 +163,68 @@ construction_test()
 // - testing element access ---------------------------------------------------
 // ----------------------------------------------------------------------------

-void element_access_test() 
+void element_access_test()
 {
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  double d = 2.7; 
+  double d = 2.7;
  A a;
-  tuple<int, double&, const A&> t(1, d, a);
-  const tuple<int, double&, const A> ct = t;
+  tuple<int, double&, const A&, int> t(1, d, a, 2);
+  const tuple<int, double&, const A, int> ct = t;

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

-  double e = tuples::get<1>(t);
+  double e = get<1>(t);
  BOOST_TEST(e > 2.69 && e < 2.71);
-	     
-  tuples::get<1>(t) = 3.14+i;
-  BOOST_TEST(tuples::get<1>(t) > 4.13 && tuples::get<1>(t) < 4.15);
+     
+  get<1>(t) = 3.14+i;
+  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);

-  //  tuples::get<4>(t) = A(); // can't assign to const
-  //  dummy(tuples::get<5>(ct)); // illegal index
+  //  get<4>(t) = A(); // can't assign to const
+  //  dummy(get<5>(ct)); // illegal index

-  ++tuples::get<0>(t);
-  BOOST_TEST(tuples::get<0>(t) == 6);
+  ++get<0>(t);
+  BOOST_TEST(get<0>(t) == 6);

-  dummy(i); dummy(j); dummy(e); // avoid warns for unused variables
+  dummy(i); dummy(i2); dummy(j); dummy(e); // avoid warns for unused variables
+#else
+  double d = 2.7; 
+  A a;
+  tuple<int, double, const A, int> t(1, d, a, 2);
+
+  int i  = get<0>(t);
+  int i2 = get<3>(t);
+
+  BOOST_TEST(i == 1 && i2 == 2);
+   
+  get<0>(t) = 5;
+  BOOST_TEST(t.head == 5);
+   
+  //  get<0>(ct) = 5; // can't assign to const
+
+  double e = get<1>(t);
+  BOOST_TEST(e > 2.69 && e < 2.71);
+     
+  get<1>(t) = 3.14+i;
+  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
+
+  //  get<4>(t) = A(); // can't assign to const
+  //  dummy(get<5>(ct)); // illegal index
+
+  ++get<0>(t);
+  BOOST_TEST(get<0>(t) == 6);
+
+  dummy(i); dummy(i2); dummy(e); // avoid warns for unused variables
 #endif
 }

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

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

 // testing copy and assignment with implicit conversions between elements
 // testing tie
@ -237,15 +268,15 @@ void
 mutate_test()
 {
  tuple<int, float, bool, foo> t1(5, 12.2f, true, foo(4));
-  tuples::get<0>(t1) = 6;
-  tuples::get<1>(t1) = 2.2f;
-  tuples::get<2>(t1) = false;
-  tuples::get<3>(t1) = foo(5);
+  get<0>(t1) = 6;
+  get<1>(t1) = 2.2f;
+  get<2>(t1) = false;
+  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));
+  BOOST_TEST(get<0>(t1) == 6);
+  BOOST_TEST(get<1>(t1) > 2.1f && get<1>(t1) < 2.3f);
+  BOOST_TEST(get<2>(t1) == false);
+  BOOST_TEST(get<3>(t1) == foo(5));
 }

 // ----------------------------------------------------------------------------
@ -256,13 +287,13 @@ void
 make_tuple_test()
 {
  tuple<int, char> t1 = make_tuple(5, 'a');
-  BOOST_TEST(tuples::get<0>(t1) == 5);
-  BOOST_TEST(tuples::get<1>(t1) == 'a');
+  BOOST_TEST(get<0>(t1) == 5);
+  BOOST_TEST(get<1>(t1) == 'a');

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


 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
@ -277,7 +308,7 @@ make_tuple_test()
     
 // the result of make_tuple is assignable:
   BOOST_TEST(make_tuple(2, 4, 6) == 
-	     (make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));
+             (make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));

 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
    make_tuple("Donald", "Daisy"); // should work;
@ -364,6 +395,7 @@ equality_test()
  tuple<int, char> t4(2, 'a');
  BOOST_TEST(t1 != t3);
  BOOST_TEST(t1 != t4);
+  BOOST_TEST(!(t1 != t2));
 }


@ -405,7 +437,7 @@ void cons_test()
  BOOST_TEST(make_tuple(3,2,1)==c);

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

@ -415,10 +447,30 @@ void cons_test()
 void const_tuple_test()
 {
  const tuple<int, float> t1(5, 3.3f);
-  BOOST_TEST(tuples::get<0>(t1) == 5);
-  BOOST_TEST(tuples::get<1>(t1) == 3.3f);
+  BOOST_TEST(get<0>(t1) == 5);
+  BOOST_TEST(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 ---------------------------------------------------------------------
@ -436,5 +488,13 @@ int test_main(int, char *[]) {
  ordering_test();
  cons_test();
  const_tuple_test();
+  tuple_length_test();
  return 0;
 }
+
+
+
+
+
+
+
Author	SHA1	Message	Date
nobody	9a05a2ebe0	This commit was manufactured by cvs2svn to create branch 'python-v2-dev'. [SVN r14785]	2002-08-12 13:35:54 +00:00
Douglas Gregor	788896864a	Fixed a dumb typo (thanks Marsh) [SVN r14232]	2002-06-24 14:20:29 +00:00
Jaakko Järvi	d24e9b9a72	added a test for != [SVN r14091]	2002-06-06 15:47:23 +00:00
Jaakko Järvi	22d8e8ecc0	fixed != by suggestion of Björn Karlsson [SVN r14090]	2002-06-06 15:44:51 +00:00
Jaakko Järvi	08be3cbe04	removing tabs [SVN r13783]	2002-05-09 17:26:37 +00:00
Jaakko Järvi	b1621fad71	removed the demand for element types being copy constructible [SVN r13729]	2002-05-07 21:44:26 +00:00
Jaakko Järvi	001f5b4c14	Previous changes broke tuples for Borland, this should fix it [SVN r13611]	2002-05-01 20:53:44 +00:00
Jaakko Järvi	75d7917f66	- tuple types can now have void and plain function types as elements - tuple objects can hold non-copyable objects (such as arrays) [SVN r13525]	2002-04-19 19:32:19 +00:00
John Maddock	6d2cb1d793	Fixed VC7 compile problems (thanks to Sofus Mortensen). [SVN r13482]	2002-04-14 11:45:32 +00:00
John Maddock	ce02fa0c58	Removed crazy mess up from previous change: (the body of the test was commented out with #if 0) [SVN r12454]	2002-01-23 12:40:44 +00:00
Dave Abrahams	5f196d037f	added missing "inherited" typedef [SVN r12332]	2002-01-17 07:47:25 +00:00
John Maddock	2ab1b6705f	Changed occurances of "tuples::get" to "get" to verify new forwarding code in tuples.hpp [SVN r12291]	2002-01-13 12:12:48 +00:00
John Maddock	55a83b6408	Added forwarding get functions to solve problems with using::tuples::get statement. [SVN r12290]	2002-01-13 12:09:39 +00:00
Jaakko Järvi	c89357006b	reflecting the removal of src/tuple.cpp [SVN r12023]	2001-12-12 22:20:42 +00:00
Jaakko Järvi	2fe366f263	reflecting the change to remove tuple.cpp, adding some thanks [SVN r12022]	2001-12-12 22:17:09 +00:00
Jaakko Järvi	8b3b6efe24	not needed anymore [SVN r12021]	2001-12-12 22:08:12 +00:00
Jaakko Järvi	2e825630f8	made the iomanipulator storage indexes static members of a class. Now all code can be in header files. [SVN r12020]	2001-12-12 21:35:41 +00:00
Jaakko Järvi	8408cc0bd5	thomas witt:s patch for icl501, adds a workaround for explicitly qualified arguments Also fixed length, so that it now works for empty tuples as well [SVN r11722]	2001-11-16 23:27:08 +00:00
Jaakko Järvi	8f29dbe149	Thomas Witt's patch for icl501: adds better test coverage + tests for length template [SVN r11721]	2001-11-16 23:24:43 +00:00
Jaakko Järvi	e531e7ce2e	added a comment about performance penalties with some compilers [SVN r11603]	2001-11-05 21:18:48 +00:00
Jaakko Järvi	a6d8c4f20c	superseded by boost/ref.hpp [SVN r11275]	2001-09-26 13:23:31 +00:00
Peter Dimov	cd416f50be	Changed tuple.hpp to use ref.hpp [SVN r11274]	2001-09-26 12:27:43 +00:00
Darin Adler	9559531c52	Fixed unused variables that show up as warnings when doing regression tests. [SVN r11241]	2001-09-24 23:21:16 +00:00
Darin Adler	4503ed841b	Get rid of unused parameter to avoid warnings. [SVN r11214]	2001-09-22 19:36:44 +00:00
John Maddock	a9b6ca508a	Borland C++ fixes: typedef dependent types before using them. [SVN r11198]	2001-09-22 11:51:14 +00:00
Jaakko Järvi	063758ef7f	added full namespace qualifiers in get<N> calls to avoid errors in edg-strict mode [SVN r11133]	2001-09-17 10:32:32 +00:00
Jaakko Järvi	66ae617224	small change to avoid a warning for an unused variable [SVN r11132]	2001-09-17 10:31:44 +00:00
Jaakko Järvi	5b40ff62c6	merged tuples_subnamespace branch to main trunk [SVN r11121]	2001-09-14 07:55:58 +00:00
Jaakko Järvi	531fb617eb	Merged the tuples_subnamespace branch to main trunk. [SVN r11120]	2001-09-14 07:55:25 +00:00
Jaakko Järvi	2764718489	Reintroduced tuples subnamespace, documents now reflect that change [SVN r11119]	2001-09-14 07:54:33 +00:00
Douglas Gregor	e1bba349b3	tuple_basic_no_partial_spec.hpp: - Fixed cons construction for compilers with no partial specialization that aren't MSVC [SVN r11056]	2001-09-06 22:05:24 +00:00