This commit was manufactured by cvs2svn to create branch

'python-v2-dev'. [SVN r14785]
Fixed a dumb typo (thanks Marsh)
2025-06-26 12:31:55 +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() {
+  get(BOOST_TUPLE_SINGLE_DUMMY_PARM) {
-    return boost::get<N>(*this);
+    return boost::tuples::get<N>(*this);
  }
  template <int N>
  typename access_traits<
             typename element<N, cons>::type
           >::const_type
-  get() const {
+  get(BOOST_TUPLE_SINGLE_DUMMY_PARM) const {
-    return boost::get<N>(*this);
+    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(
+  tuple() {}
-    typename access_traits<T0>::parameter_type t0 
+  
-      = detail::default_arg<T0>::f(),
+  tuple(typename access_traits<T0>::parameter_type t0)
-    typename access_traits<T1>::parameter_type t1 
+    : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(), 
-      = detail::default_arg<T1>::f(),
+                detail::cnull(), detail::cnull(), detail::cnull(), 
-    typename access_traits<T2>::parameter_type t2 
+                detail::cnull(), detail::cnull(), detail::cnull()) {}
-      = detail::default_arg<T2>::f(),
+
-    typename access_traits<T3>::parameter_type t3 
+  tuple(typename access_traits<T0>::parameter_type t0,
-      = detail::default_arg<T3>::f(),
+        typename access_traits<T1>::parameter_type t1)
-    typename access_traits<T4>::parameter_type t4 
+    : inherited(t0, t1, detail::cnull(), detail::cnull(), 
-      = detail::default_arg<T4>::f(),
+                detail::cnull(), detail::cnull(), detail::cnull(), 
-    typename access_traits<T5>::parameter_type t5 
+                detail::cnull(), detail::cnull(), detail::cnull()) {}
-      = detail::default_arg<T5>::f(),
+
-    typename access_traits<T6>::parameter_type t6 
+  tuple(typename access_traits<T0>::parameter_type t0,
-      = detail::default_arg<T6>::f(),
+        typename access_traits<T1>::parameter_type t1,
-    typename access_traits<T7>::parameter_type t7 
+        typename access_traits<T2>::parameter_type t2)
-      = detail::default_arg<T7>::f(),
+    : inherited(t0, t1, t2, detail::cnull(), detail::cnull(), 
-    typename access_traits<T8>::parameter_type t8 
+                detail::cnull(), detail::cnull(), detail::cnull(), 
-      = detail::default_arg<T8>::f(),
+                detail::cnull(), detail::cnull()) {}
-    typename access_traits<T9>::parameter_type t9 
+
-      = detail::default_arg<T9>::f())
+  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
+  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3>::type t;
-           (t0, t1, t2, t3); 
+  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
+  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type t;
-           (t0, t1, t2, t3, t4); 
+  return t(t0, t1, t2, t3, t4); 
 }
 template<class T0, class T1, class T2, class T3, class T4, class T5>
 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
+  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type t;
-           (t0, t1, t2, t3, t4, t5); 
+  return t(t0, t1, t2, t3, t4, t5); 
 }
 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
 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
+  typedef typename detail::make_tuple_mapper
-           <T0, T1, T2, T3, T4, T5, T6>::type
+           <T0, T1, T2, T3, T4, T5, T6>::type t;
-           (t0, t1, t2, t3, t4, t5, t6); 
+  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
+  typedef typename detail::make_tuple_mapper
-           <T0, T1, T2, T3, T4, T5, T6, T7>::type
+           <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
-           (t0, t1, t2, t3, t4, t5, t6, t7); 
+  return t(t0, t1, t2, t3, t4, t5, t6, t7); 
 }
 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
@ -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
+  typedef typename detail::make_tuple_mapper
-           <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
+           <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
-           (t0, t1, t2, t3, t4, t5, t6, t7, t8); 
+  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8); 
 }
 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
@ -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
+  typedef 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>::type t;
-           (t0, t1, t2, t3, t4, t5, t6, t7, t8, t9); 
+  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 T2, 
-      typename T3 = null_type, 
+      typename T3, 
-      typename T4 = null_type,
+      typename T4,
-      typename T5 = null_type,
+      typename T5,
-      typename T6 = null_type,
+      typename T6,
-      typename T7 = null_type,
+      typename T7,
-      typename T8 = null_type,
+      typename T8,
-      typename T9 = null_type,
+      typename T9,
-      typename T10 = null_type
+      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>(&t5),
-                        detail::assign_to_pointee<T5>(&t6));
+                        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 open : c = '('; break;
-         case close : 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 open :  c = i.widen('('); break;
-         case close : 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_TEMPLATE_PARTIAL_SPECIALIZATION
-#endif	// BOOST_NO_TEMPLATED_STREAMS
+#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; 
+  tuple<int> t1;
-  BOOST_TEST(tuples::get<0>(t1) == int());
+  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(get<0>(t5) == int());
-  BOOST_TEST(tuples::get<1>(t5) == float());
+  BOOST_TEST(get<1>(t5) == float());
  tuple<int, float> t6(12, 5.5f);
-  BOOST_TEST(tuples::get<0>(t6) == 12);
+  BOOST_TEST(get<0>(t6) == 12);
-  BOOST_TEST(tuples::get<1>(t6) > 5.4f && tuples::get<1>(t6) < 5.6f);
+  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(get<0>(t7) == 12);
-  BOOST_TEST(tuples::get<1>(t7) > 5.4f && tuples::get<1>(t7) < 5.6f);
+  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(get<0>(t8) == 12);
-  BOOST_TEST(tuples::get<1>(t8) > 5.4f && tuples::get<1>(t8) < 5.6f);
+  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);
+  tuple<int, double&, const A&, int> t(1, d, a, 2);
-  const tuple<int, double&, const A> ct = t;
+  const tuple<int, double&, const A, int> ct = t;
-  int i = tuples::get<0>(t);
+  int i  = get<0>(t);
-  int j = tuples::get<0>(ct);
+  int i2 = get<3>(t);
-  BOOST_TEST(i == 1 && j == 1);
+
  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;
+  get<1>(t) = 3.14+i;
-  BOOST_TEST(tuples::get<1>(t) > 4.13 && tuples::get<1>(t) < 4.15);
+  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
-  //  tuples::get<4>(t) = A(); // can't assign to const
+  //  get<4>(t) = A(); // can't assign to const
-  //  dummy(tuples::get<5>(ct)); // illegal index
+  //  dummy(get<5>(ct)); // illegal index
-  ++tuples::get<0>(t);
+  ++get<0>(t);
-  BOOST_TEST(tuples::get<0>(t) == 6);
+  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(get<0>(t1) == get<0>(t2));
-  BOOST_TEST(tuples::get<1>(t1) == tuples::get<1>(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((double)get<0>(t1) == get<0>(t3));
-  BOOST_TEST(tuples::get<1>(t1) == tuples::get<1>(t3)[0]);
+  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;
+  get<0>(t1) = 6;
-  tuples::get<1>(t1) = 2.2f;
+  get<1>(t1) = 2.2f;
-  tuples::get<2>(t1) = false;
+  get<2>(t1) = false;
-  tuples::get<3>(t1) = foo(5);
+  get<3>(t1) = foo(5);
-  BOOST_TEST(tuples::get<0>(t1) == 6);
+  BOOST_TEST(get<0>(t1) == 6);
-  BOOST_TEST(tuples::get<1>(t1) > 2.1f && tuples::get<1>(t1) < 2.3f);
+  BOOST_TEST(get<1>(t1) > 2.1f && get<1>(t1) < 2.3f);
-  BOOST_TEST(tuples::get<2>(t1) == false);
+  BOOST_TEST(get<2>(t1) == false);
-  BOOST_TEST(tuples::get<3>(t1) == foo(5));
+  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(get<0>(t1) == 5);
-  BOOST_TEST(tuples::get<1>(t1) == 'a');
+  BOOST_TEST(get<1>(t1) == 'a');
  tuple<int, std::string> t2;
  t2 = make_tuple((short int)2, std::string("Hi"));
-  BOOST_TEST(tuples::get<0>(t2) == 2);
+  BOOST_TEST(get<0>(t2) == 2);
-  BOOST_TEST(tuples::get<1>(t2) == "Hi");
+  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(get<0>(t1) == 5);
-  BOOST_TEST(tuples::get<1>(t1) == 3.3f);
+  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