Removed part of the Boost files from the SPIRIT_MINIBOOST branch.

[SVN r26362]
This commit was manufactured by cvs2svn to create branch
2025-07-28 19:57:22 +02:00 · 2004-11-29 21:25:31 +00:00 · 2004-11-29 07:29:20 +00:00
12 changed files with 217 additions and 1836 deletions
--- a/doc/design_decisions_rationale.html
+++ b/doc/design_decisions_rationale.html
@ -1,4 +1,3 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>

 <title>Design decisions rationale for Boost Tuple Library</title>
@ -21,8 +20,8 @@ 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):</p>
-<pre><code>namespace boost {
+This is accomplished with using declarations (suggested by Dave Abrahams):
+<code><pre>namespace boost {
  namespace tuples {
      ...      
    // All library code
@ -33,8 +32,8 @@ This is accomplished with using declarations (suggested by Dave Abrahams):</p>
  using tuples::tie;
  using tuples::get;
 }
-</code></pre>
-<p>With this arrangement, tuple creation with direct constructor calls, <code>make_tuple</code> or <code>tie</code> functions do not need the namespace qualifier.
+</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.
@ -55,9 +54,9 @@ The rationale for not using the most natural name 'tuple' is to avoid having an
 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:</p>
+Both gcc and edg compilers reject using declarations where the namespace and class names are identical:

-<pre><code>namespace boost {
+<code><pre>namespace boost {
  namespace tuple {
    ... tie(...);
    class tuple; 
@ -67,13 +66,13 @@ Both gcc and edg compilers reject using declarations where the namespace and cla
  using tuple::tuple; // error
    ...
 }
-</code></pre>
+</pre></code>

-<p>Note, however, that a corresponding using declaration in the global namespace seems to be ok:</p>
+Note, however, that a corresponding using declaration in the global namespace seems to be ok: 

-<pre><code>
+<code><pre>
 using boost::tuple::tuple; // ok;
-</code></pre>
+</pre></code>


 <h2>The end mark of the cons list (nil, null_type, ...)</h2>
@ -81,15 +80,14 @@ using boost::tuple::tuple; // ok;
 <p>
 Tuples are internally represented as <code>cons</code> lists:

-<pre><code>tuple&lt;int, int&gt;
-</code></pre> 
-<p>inherits from</p>
-<pre><code>cons&lt;int, cons&lt;int, null_type&gt; &gt;
+<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>

-<p>
 <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>
+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>
@ -97,22 +95,22 @@ Note that <code>null_type</code> is the internal representation of an empty tupl
 <h2>Element indexing</h2>

 <p>
-Whether to use 0- or 1-based indexing was discussed more than thoroughly, and the following observations were made:</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>
-<p>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>
+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:

-<pre><code>a.get&lt;0&gt;() == a.get(_1st) == a[_1st] == a(_1st);
-</code></pre>
+<code><pre>a.get&lt;0&gt;() == a.get(_1st) == a[_1st] == a(_1st);
+</pre></code>

-<p>We chose not to provide more than one indexing method for the following reasons:</p>
+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>
@ -127,18 +125,18 @@ Such constants are easy to add.

 <h2>Tuple comparison</h2>

-<p>The comparison operator implements lexicographical order. 
-Other orderings were considered, mainly dominance (<i>a &lt; b iff for each i a(i) &lt; 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.</p>
+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.</p>
+Streams that have character types not convertible back and forth to long thus fail to compile.

-<p>This may be revisited at some point. The two possible solutions are:</p>
+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
--- a/doc/tuple_advanced_interface.html
+++ b/doc/tuple_advanced_interface.html
@ -2,52 +2,53 @@
 <html>
  <head>
    <title>Tuple library advanced features</title>
-  </head>
-
 <body bgcolor="#FFFFFF" text="#000000">

 <IMG SRC="../../../boost.png" 
     ALT="C++ Boost" width="277" height="86">

+  </head>
+
+  <body>
    <h1>Tuple library advanced features</h1>

 The advanced features described in this document are all under namespace <code>::boost::tuples</code>

 <h2>Metafunctions for tuple types</h2>
 <p>
-Suppose <code>T</code> is a tuple type, and <code>N</code> is a constant integral expression.</p>
+Suppose <code>T</code> is a tuple type, and <code>N</code> is a constant integral expression. 

-<pre><code>element&lt;N, T&gt;::type</code></pre>
+<code><pre>element&lt;N, T&gt;::type</pre></code>

-<p>gives the type of the <code>N</code>th element in the tuple type <code>T</code>. If <code>T</code> is const, the resulting type is const qualified as well. 
+gives the type of the <code>N</code>th element in the tuple type <code>T</code>. If <code>T</code> is const, the resulting type is const qualified as well. 
 Note that the constness of <code>T</code> does not affect reference type
 elements.
 </p>

-<pre><code>length&lt;T&gt;::value</code></pre>
+<code><pre>length&lt;T&gt;::value</pre></code>

-<p>gives the length of the tuple type <code>T</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 </p>
+For example, the tuple 

-<pre><code>tuple&lt;A, B, C, D&gt;</code></pre>
+<code><pre>tuple&lt;A, B, C, D&gt;</pre></code>

-<p>inherits from the type</p>
-<pre><code>cons&lt;A, cons&lt;B, cons&lt;C, cons&lt;D, null_type&gt; &gt; &gt; &gt;
-</code></pre>
+ 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>

-<p>The tuple template provides the typedef <code>inherited</code> to access the cons list representation. E.g.:
+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>.
+The internal representation of the empty tuple <code>tuple&lt;&gt</code> is <code>null_type</code>.
 </p>

 <h4>Head and tail</h4>
@ -83,11 +84,11 @@ inline void set_to_zero(cons&lt;H, T&gt;&amp; x) { x.get_head() = 0; set_to_zero
 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:</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>
-<p>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).
+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.
@ -98,16 +99,16 @@ For a one-element cons list the tail argument (<code>null_type</code>) can be om

 <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:</p>
+The template <code>access_traits</code> defines three type functions. Let <code>T</code> be a type of an element in a tuple:
 <ol>
-<li><code>access_traits&lt;T&gt;::non_const_type</code> maps <code>T</code> to the return type of the non-const access functions (nonmember and member <code>get</code> functions, and the <code>get_head</code> function).</li>
+<li><code>access_traits&lt;T&gt;::type</code> maps <code>T</code> to the return type of the non-const access functions (nonmeber and member <code>get</code> functions, and the <code>get_head</code> function).</li>
 <li><code>access_traits&lt;T&gt;::const_type</code> maps <code>T</code> to the return type of the const access functions.</li>
 <li><code>access_traits&lt;T&gt;::parameter_type</code> maps <code>T</code> to the parameter type of the tuple constructor.</li>
 </ol>
 <h4><code>make_tuple_traits</code></h4>

-<p>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:</p>
+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>
@ -119,7 +120,7 @@ The type function call <code>make_tuple_traits&lt;T&gt;::type</code> implements
 </li>
 </ul>

-<p>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>.)
+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. 
--- a/doc/tuple_users_guide.html
+++ b/doc/tuple_users_guide.html
@ -1,4 +1,3 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
 <title>The Boost Tuple Library</title>
@ -54,22 +53,20 @@ To compensate for this &quot;deficiency&quot;, the Boost Tuple Library implement

 <h2><a name="using_library">Using the library</a></h2>

-<p>To use the library, just include:</p>
+<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:</p>
+<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,</p>
+<p>To use tuple input and output operators,

 <pre><code>#include &quot;boost/tuple/tuple_io.hpp&quot;</code></pre>

-<p>Both <code>tuple_io.hpp</code> and <code>tuple_comparison.hpp</code> include <code>tuple.hpp</code>.</p>
+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.</p>
+<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>

@ -83,11 +80,11 @@ 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 copied, or that are not default constructible (see 'Constructing tuples'
- below). </p>
+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):</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;
@ -101,7 +98,7 @@ tuple&lt;A*, tuple&lt;const A*, const B&amp;, C&gt;, bool, void*&gt;
 <p>
 The tuple constructor takes the tuple elements as arguments. 
 For an <i>n</i>-element tuple, the constructor can be invoked with <i>k</i> arguments, where 0 &lt;= <i>k</i> &lt;= <i>n</i>.
-For example:</p>
+For example:
 <pre><code>tuple&lt;int, double&gt;() 
 tuple&lt;int, double&gt;(1) 
 tuple&lt;int, double&gt;(1, 3.14)
@ -109,7 +106,7 @@ tuple&lt;int, double&gt;(1, 3.14)

 <p>
 If no initial value for an element is provided, it is default initialized (and hence must be default initializable).
-For example.</p>
+For example.

 <pre><code>class X {
  X(); 
@ -121,7 +118,7 @@ tuple&lt;X,X,X&gt;()                                              // error: no d
 tuple&lt;X,X,X&gt;(string(&quot;Jaba&quot;), string(&quot;Daba&quot;), string(&quot;Duu&quot;)) // ok
 </code></pre>

-<p>In particular, reference types do not have a default initialization: </p>
+In particular, reference types do not have a default initialization: 

 <pre><code>tuple&lt;double&amp;&gt;()                // error: reference must be 
                                // initialized explicitly
@ -137,7 +134,7 @@ tuple&lt;const double&amp;&gt;(d+3.14)    // ok, but dangerous:
 </code></pre>

 <p>Using an initial value for an element that cannot be copied, is a compile
-time error:</p>
+time error:

 <pre><code>class Y { 
  Y(const Y&amp;); 
@ -151,15 +148,15 @@ 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>

-<p>Note particularly that the following is perfectly ok:</p>
-<pre><code>Y y;
+Note particularly that the following is perfectly ok:
+<code><pre>Y y;
 tuple&lt;char(&amp;)[10], Y&amp;&gt;(a, y); 
 </code></pre>

-<p>It is possible to come up with a tuple type that cannot be constructed.
+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>
+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>
@ -168,19 +165,19 @@ For example: <code>tuple&lt;char[10], int&amp;&gt;</code>.</p>

 <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:</p>
+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.: </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>
-<p>The <code>make_tuple</code> invocation results in a tuple of type <code>tuple&lt;A, B&gt;</code>.</p>
+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. 
@ -188,9 +185,8 @@ Therefore, the programmer can control the type deduction and state that a refere
 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 example below).
-For example:</p>
+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;
@ -202,19 +198,19 @@ make_tuple(ref(ca));         // creates tuple&lt;const A&amp;&gt;


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

-<p>This creates an object of type <code>tuple&lt;const char (&amp;)[7], const char (&amp;)[6]&gt;</code> 
+This creates an object of type <code>tuple&lt;const char (&amp;)[7], const char (&amp;)[6]&gt;</code> 
 (note that the type of a string literal is an array of const characters, not <code>const char*</code>). 
 However, to get <code>make_tuple</code> to create a tuple with an element of a
-non-const array type one must use the <code>ref</code> wrapper.</p>
+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):</p>
+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;
@ -226,19 +222,19 @@ make_tuple(f);                    // not ok
 <h2><a name = "accessing_elements">Accessing tuple elements</a></h2>

 <p>
-Tuple elements are accessed with the expression:</p>
+Tuple elements are accessed with the expression:

 <pre><code>t.get&lt;N&gt;()
 </code></pre>
-<p>or</p>
+or
 <pre><code>get&lt;N&gt;(t)
 </code></pre>
-<p>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.
+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 constraints are detected at compile time. Examples:</p>
+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);
@ -257,18 +253,16 @@ 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>

-<p>
 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 should compile with MSVC++ 6.0.
-</p>
+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:</p>
+For example:

 <pre><code>class A {};
 class B : public A {};
@ -280,32 +274,32 @@ tuple&lt;int, A*, C, C&gt; a(t); // ok
 a = t;                     // ok 
 </code></pre>

-<p>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>
+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:</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;, &gt;, &lt;=</code> and <code>>=</code> to the corresponding elementary operators. 
+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:</p>
+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>

-<p>The operators <code>&lt;, &gt;, &lt;=</code> and <code>&gt;=</code> implement a lexicographical ordering.</p>
+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.
-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>
+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:</p>
+<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());
@ -322,7 +316,7 @@ t1 == t3;               // false, does not print &quot;All the...&quot;

 <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>):</p>
+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; 
  ...
@ -335,26 +329,26 @@ The same result could be achieved with the call <code>make_tuple(ref(i), ref(c),
 </p>

 <p>
-A tuple that contains non-const references as elements can be used to 'unpack' another tuple into variables. E.g.:</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>
-<p>This code prints <code>1 a 5.5</code> to the standard output stream.
+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>
+It is convenient when calling functions which return tuples.

 <p>
-The tying mechanism works with <code>std::pair</code> templates as well:</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>
-<p>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):</p>
+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');
@ -380,10 +374,10 @@ For Example:

 cout &lt;&lt; a; 
 </code></pre>
-<p>outputs the tuple as: <code>(1.0 2 Howdy folks!)</code></p>
+outputs the tuple as: <code>(1.0 2 Howdy folks!)</code>

 <p>
-The library defines three <i>manipulators</i> for changing the default behavior:</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>
@ -393,27 +387,27 @@ last element.</li>
 elements.</li>
 </ul>

-<p>Note, that these manipulators are defined in the <code>tuples</code> subnamespace.
-For example:</p>
-<pre><code>cout &lt;&lt; tuples::set_open('[') &lt;&lt; tuples::set_close(']') &lt;&lt; tuples::set_delimiter(',') &lt;&lt; a; 
+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>
-<p>outputs the same tuple <code>a</code> as: <code>[1.0,2,Howdy folks!]</code></p>
+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>

-<p>The code:</p>
+The code:

-<pre><code>tuple&lt;int, int, int&gt; i;
+<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; tuples::set_delimiter(':');
+cin &gt;&gt; tuples::set_open('[') &gt;&gt; tuples::set_close(']') &gt;&gt; tules::set_delimiter(':');
 cin &gt;&gt; j;
 </code></pre>

-<p>reads the data into the tuples <code>i</code> and <code>j</code>.</p>
+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
@ -423,9 +417,9 @@ parseable.

 <h2><a name = "performance">Performance</a></h2>

-<p>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:</p>
+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;
@ -441,7 +435,7 @@ hand_made_tuple hmt(A(), B(), C());
 hmt.getA(); hmt.getB(); hmt.getC();
 </code></pre>

-<p>and this code:</p>
+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;(); 
@ -452,23 +446,23 @@ t.get&lt;0&gt;(); t.get&lt;1&gt;(); t.get&lt;2&gt;();
 <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:</p>
+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>

-<p>Then, the call #1 may be slightly faster than #2 in the code below:</p>
+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>
-<p>See 
+See 
 [<a href="#publ_1">1</a>,
 <a href="#publ_2">2</a>]
- for more in-depth discussions about efficiency.</p>
+ for more in-depth discussions about efficiency.

 <h4>Effect on Compile Time</h4>

@ -476,7 +470,7 @@ tie(i,d) = f2(); // #2
 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 and 10 percent were measured for programs which used tuples very frequently.
+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>]
@ -498,20 +492,20 @@ Below is a list of compilers and known problems with each compiler:
 </table>

 <h2><a name = "thanks">Acknowledgements</a></h2>
-<p>Gary Powell has been an indispensable helping hand. In particular, stream manipulators for tuples were his idea. Doug Gregor came up with a working version for MSVC, David Abrahams found a way to get rid of most of the restrictions for compilers not supporting partial specialization. Thanks to Jeremy Siek, William Kempf and Jens Maurer for their help and suggestions. 
+Gary Powell has been an indispensable helping hand. In particular, stream manipulators for tuples were his idea. Doug Gregor came up with a working version for MSVC, David Abrahams found a way to get rid of most of the restrictions for compilers not supporting partial specialization. Thanks to Jeremy Siek, William Kempf and Jens Maurer for their help and suggestions. 
 The comments by Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes, David Abrahams and Hartmut Kaiser helped to improve the
 library.
-The idea for the tie mechanism came from an old usenet article by Ian McCulloch, where he proposed something similar for std::pairs.</p>
+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>)-->.
+J&auml;rvi J.: <i>Tuples and multiple return values in C++</i>, TUCS Technical Report No 249, 1999 (<a href="http://www.tucs.fi/Publications">http://www.tucs.fi/Publications</a>).
 </p>

 <p>
 <a name="publ_2"></a>[2]
-J&auml;rvi J.: <i>ML-Style Tuple Assignment in Standard C++ - Extending the Multiple Return Value Formalism</i>, TUCS Technical Report No 267, 1999<!-- (<a href="http://www.tucs.fi/Publications">http://www.tucs.fi/Publications</a>)-->.
+J&auml;rvi J.: <i>ML-Style Tuple Assignment in Standard C++ - Extending the Multiple Return Value Formalism</i>, TUCS Technical Report No 267, 1999 (<a href="http://www.tucs.fi/Publications">http://www.tucs.fi/Publications</a>).
 </p>

 <p>
@ -522,7 +516,7 @@ J&auml;rvi J.: <i>ML-Style Tuple Assignment in Standard C++ - Extending the Mult

 <p>Last modified 2003-09-07</p>

-<p>&copy; Copyright <a href="http://www.boost.org/people/jaakko_jarvi.htm"> Jaakko J&auml;rvi</a> 2001. 
+<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.
--- a/include/boost/tuple/detail/tuple_basic.hpp
+++ b/include/boost/tuple/detail/tuple_basic.hpp
@ -1,989 +0,0 @@
-//  tuple_basic.hpp -----------------------------------------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// For more information, see http://www.boost.org
-
-// Outside help:
-// This and that, Gary Powell.
-// Fixed return types for get_head/get_tail
-// ( and other bugs ) per suggestion of Jens Maurer
-// simplified element type accessors + bug fix  (Jeremy Siek)
-// Several changes/additions according to suggestions by Douglas Gregor,
-// William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes,
-// 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<>.
-// -----------------------------------------------------------------
-
-#ifndef BOOST_TUPLE_BASIC_HPP
-#define BOOST_TUPLE_BASIC_HPP
-
-
-#include <utility> // needed for the assignment from pair to tuple
-
-#include "boost/type_traits/cv_traits.hpp"
-#include "boost/type_traits/function_traits.hpp"
-#include "boost/utility/swap.hpp"
-
-#include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND
-
-#if BOOST_GCC >= 40700
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
-#endif
-
-namespace boost {
-namespace tuples {
-
-// -- null_type --------------------------------------------------------
-struct null_type {};
-
-// a helper function to provide a const null_type type temporary
-namespace detail {
-  inline const null_type cnull() { return null_type(); }
-
-
-// -- if construct ------------------------------------------------
-// Proposed by Krzysztof Czarnecki and Ulrich Eisenecker
-
-template <bool If, class Then, class Else> struct IF { typedef Then RET; };
-
-template <class Then, class Else> struct IF<false, Then, Else> {
-  typedef Else RET;
-};
-
-} // end detail
-
-// - cons forward declaration -----------------------------------------------
-template <class HT, class TT> struct cons;
-
-
-// - tuple forward declaration -----------------------------------------------
-template <
-  class T0 = null_type, class T1 = null_type, class T2 = null_type,
-  class T3 = null_type, class T4 = null_type, class T5 = null_type,
-  class T6 = null_type, class T7 = null_type, class T8 = null_type,
-  class T9 = null_type>
-class tuple;
-
-// tuple_length forward declaration
-template<class T> struct length;
-
-
-
-namespace detail {
-
-// -- generate error template, referencing to non-existing members of this
-// template is used to produce compilation errors intentionally
-template<class T>
-class generate_error;
-
-template<int N>
-struct drop_front {
-    template<class Tuple>
-    struct apply {
-        typedef BOOST_DEDUCED_TYPENAME drop_front<N-1>::BOOST_NESTED_TEMPLATE
-            apply<Tuple> next;
-        typedef BOOST_DEDUCED_TYPENAME next::type::tail_type type;
-        static const type& call(const Tuple& tup) {
-            return next::call(tup).tail;
-        }
-    };
-};
-
-template<>
-struct drop_front<0> {
-    template<class Tuple>
-    struct apply {
-        typedef Tuple type;
-        static const type& call(const Tuple& tup) {
-            return tup;
-        }
-    };
-};
-
-} // end of namespace detail
-
-
-// -cons type accessors ----------------------------------------
-// typename tuples::element<N,T>::type gets the type of the
-// Nth element ot T, first element is at index 0
-// -------------------------------------------------------
-
-#ifndef BOOST_NO_CV_SPECIALIZATIONS
-
-template<int N, class T>
-struct element
-{
-  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
-      apply<T>::type::head_type type;
-};
-
-template<int N, class T>
-struct element<N, const T>
-{
-private:
-  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
-      apply<T>::type::head_type unqualified_type;
-public:
-#if BOOST_WORKAROUND(__BORLANDC__,<0x600)
-  typedef const unqualified_type type;
-#else
-  typedef BOOST_DEDUCED_TYPENAME boost::add_const<unqualified_type>::type type;
-#endif
-};
-#else // def BOOST_NO_CV_SPECIALIZATIONS
-
-namespace detail {
-
-template<int N, class T, bool IsConst>
-struct element_impl
-{
-  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
-      apply<T>::type::head_type type;
-};
-
-template<int N, class T>
-struct element_impl<N, T, true /* IsConst */>
-{
-  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
-      apply<T>::type::head_type unqualified_type;
-  typedef const unqualified_type type;
-};
-
-} // end of namespace detail
-
-
-template<int N, class T>
-struct element:
-  public detail::element_impl<N, T, ::boost::is_const<T>::value>
-{
-};
-
-#endif
-
-
-// -get function templates -----------------------------------------------
-// Usage: get<N>(aTuple)
-
-// -- some traits classes for get functions
-
-// access traits lifted from detail namespace to be part of the interface,
-// (Joel de Guzman's suggestion). Rationale: get functions are part of the
-// interface, so should the way to express their return types be.
-
-template <class T> struct access_traits {
-  typedef const T& const_type;
-  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,
-// and when binding temporaries to references, the reference must
-// be non-volatile and const. 8.5.3. (5)
-};
-
-template <class T> struct access_traits<T&> {
-
-  typedef T& const_type;
-  typedef T& non_const_type;
-
-  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) {
-  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
-      apply<cons<HT, TT> > impl;
-  typedef BOOST_DEDUCED_TYPENAME impl::type cons_element;
-  return const_cast<cons_element&>(impl::call(c)).head;
-}
-
-// 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 access_traits<
-                  typename element<N, cons<HT, TT> >::type
-                >::const_type
-get(const cons<HT, TT>& c) {
-  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
-      apply<cons<HT, TT> > impl;
-  return impl::call(c).head;
-}
-
-// -- 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 {
-
-  typedef HT head_type;
-  typedef TT tail_type;
-
-  typedef typename
-    detail::wrap_non_storeable_type<head_type>::type stored_head_type;
-
-  stored_head_type head;
-  tail_type tail;
-
-  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<stored_head_type>::const_type
-  get_head() const { return head; }
-
-  typename access_traits<tail_type>::const_type
-  get_tail() const { return tail; }
-
-  cons() : head(), tail() {}
-  //  cons() : head(detail::default_arg<HT>::f()), tail() {}
-
-  // the argument for head is not strictly needed, but it prevents
-  // array type elements. This is good, since array type elements
-  // cannot be supported properly in any case (no assignment,
-  // copy works only if the tails are exactly the same type, ...)
-
-  cons(typename access_traits<stored_head_type>::parameter_type h,
-       const tail_type& t)
-    : head (h), tail(t) {}
-
-  template <class T1, class T2, class T3, class T4, class T5,
-            class T6, class T7, class T8, class T9, class T10>
-  cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5,
-        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
-    : head (t1),
-      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) {}
-
-  template <class HT2, class TT2>
-  cons& operator=( const cons<HT2, TT2>& u ) {
-    head=u.head; tail=u.tail; return *this;
-  }
-
-  // must define assignment operator explicitly, implicit version is
-  // illformed if HT is a reference (12.8. (12))
-  cons& operator=(const cons& u) {
-    head = u.head; tail = u.tail;  return *this;
-  }
-
-  template <class T1, class T2>
-  cons& operator=( const std::pair<T1, T2>& u ) {
-    BOOST_STATIC_ASSERT(length<cons>::value == 2); // check length = 2
-    head = u.first; tail.head = u.second; return *this;
-  }
-
-  // get member functions (non-const and const)
-  template <int N>
-  typename access_traits<
-             typename element<N, cons<HT, TT> >::type
-           >::non_const_type
-  get() {
-    return boost::tuples::get<N>(*this); // delegate to non-member get
-  }
-
-  template <int N>
-  typename access_traits<
-             typename element<N, cons<HT, TT> >::type
-           >::const_type
-  get() const {
-    return boost::tuples::get<N>(*this); // delegate to non-member get
-  }
-};
-
-template <class HT>
-struct cons<HT, null_type> {
-
-  typedef HT head_type;
-  typedef null_type tail_type;
-  typedef cons<HT, null_type> self_type;
-
-  typedef typename
-    detail::wrap_non_storeable_type<head_type>::type stored_head_type;
-  stored_head_type head;
-
-  typename access_traits<stored_head_type>::non_const_type
-  get_head() { return head; }
-
-  null_type get_tail() { return null_type(); }
-
-  typename access_traits<stored_head_type>::const_type
-  get_head() const { return head; }
-
-  const null_type get_tail() const { return null_type(); }
-
-  //  cons() : head(detail::default_arg<HT>::f()) {}
-  cons() : head() {}
-
-  cons(typename access_traits<stored_head_type>::parameter_type h,
-       const null_type& = null_type())
-    : head (h) {}
-
-  template<class T1>
-  cons(T1& t1, const null_type&, const null_type&, const null_type&,
-       const null_type&, const null_type&, const null_type&,
-       const null_type&, const null_type&, const null_type&)
-  : head (t1) {}
-
-  cons(const null_type&,
-       const null_type&, const null_type&, const null_type&,
-       const null_type&, const null_type&, const null_type&,
-       const null_type&, const null_type&, const null_type&)
-  : head () {}
-
-  template <class HT2>
-  cons( const cons<HT2, null_type>& u ) : head(u.head) {}
-
-  template <class HT2>
-  cons& operator=(const cons<HT2, null_type>& u )
-  { head = u.head; return *this; }
-
-  // must define assignment operator explicitely, implicit version
-  // is illformed if HT is a reference
-  cons& operator=(const cons& u) { head = u.head; return *this; }
-
-  template <int N>
-  typename access_traits<
-             typename element<N, self_type>::type
-            >::non_const_type
-  get() {
-    return boost::tuples::get<N>(*this);
-  }
-
-  template <int N>
-  typename access_traits<
-             typename element<N, self_type>::type
-           >::const_type
-  get() const {
-    return boost::tuples::get<N>(*this);
-  }
-
-};
-
-// templates for finding out the length of the tuple -------------------
-
-template<class T>
-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<tuple<> const> {
-  BOOST_STATIC_CONSTANT(int, value = 0);
-};
-
-template<>
-struct length<null_type> {
-  BOOST_STATIC_CONSTANT(int, value = 0);
-};
-
-template<>
-struct length<null_type const> {
-  BOOST_STATIC_CONSTANT(int, value = 0);
-};
-
-namespace detail {
-
-// Tuple to cons mapper --------------------------------------------------
-template <class T0, class T1, class T2, class T3, class T4,
-          class T5, class T6, class T7, class T8, class T9>
-struct map_tuple_to_cons
-{
-  typedef cons<T0,
-               typename map_tuple_to_cons<T1, T2, T3, T4, T5,
-                                          T6, T7, T8, T9, null_type>::type
-              > type;
-};
-
-// The empty tuple is a null_type
-template <>
-struct map_tuple_to_cons<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>
-{
-  typedef null_type type;
-};
-
-} // end detail
-
-// -------------------------------------------------------------------
-// -- tuple ------------------------------------------------------
-template <class T0, class T1, class T2, class T3, class T4,
-          class T5, class T6, class T7, class T8, class T9>
-
-class tuple :
-  public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
-{
-public:
-  typedef typename
-    detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited;
-  typedef typename inherited::head_type head_type;
-  typedef typename inherited::tail_type tail_type;
-
-
-// access_traits<T>::parameter_type takes non-reference types as const T&
-  tuple() {}
-
-  tuple(typename access_traits<T0>::parameter_type t0)
-    : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(),
-                detail::cnull(), detail::cnull(), detail::cnull(),
-                detail::cnull(), detail::cnull(), detail::cnull()) {}
-
-  tuple(typename access_traits<T0>::parameter_type t0,
-        typename access_traits<T1>::parameter_type t1)
-    : inherited(t0, t1, detail::cnull(), detail::cnull(),
-                detail::cnull(), detail::cnull(), detail::cnull(),
-                detail::cnull(), detail::cnull(), detail::cnull()) {}
-
-  tuple(typename access_traits<T0>::parameter_type t0,
-        typename access_traits<T1>::parameter_type t1,
-        typename access_traits<T2>::parameter_type t2)
-    : inherited(t0, t1, t2, detail::cnull(), detail::cnull(),
-                detail::cnull(), detail::cnull(), detail::cnull(),
-                detail::cnull(), detail::cnull()) {}
-
-  tuple(typename access_traits<T0>::parameter_type t0,
-        typename access_traits<T1>::parameter_type t1,
-        typename access_traits<T2>::parameter_type t2,
-        typename access_traits<T3>::parameter_type t3)
-    : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(),
-                detail::cnull(), detail::cnull(), detail::cnull(),
-                detail::cnull()) {}
-
-  tuple(typename access_traits<T0>::parameter_type t0,
-        typename access_traits<T1>::parameter_type t1,
-        typename access_traits<T2>::parameter_type t2,
-        typename access_traits<T3>::parameter_type t3,
-        typename access_traits<T4>::parameter_type t4)
-    : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(),
-                detail::cnull(), detail::cnull(), detail::cnull()) {}
-
-  tuple(typename access_traits<T0>::parameter_type t0,
-        typename access_traits<T1>::parameter_type t1,
-        typename access_traits<T2>::parameter_type t2,
-        typename access_traits<T3>::parameter_type t3,
-        typename access_traits<T4>::parameter_type t4,
-        typename access_traits<T5>::parameter_type t5)
-    : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(),
-                detail::cnull(), detail::cnull()) {}
-
-  tuple(typename access_traits<T0>::parameter_type t0,
-        typename access_traits<T1>::parameter_type t1,
-        typename access_traits<T2>::parameter_type t2,
-        typename access_traits<T3>::parameter_type t3,
-        typename access_traits<T4>::parameter_type t4,
-        typename access_traits<T5>::parameter_type t5,
-        typename access_traits<T6>::parameter_type t6)
-    : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(),
-                detail::cnull(), detail::cnull()) {}
-
-  tuple(typename access_traits<T0>::parameter_type t0,
-        typename access_traits<T1>::parameter_type t1,
-        typename access_traits<T2>::parameter_type t2,
-        typename access_traits<T3>::parameter_type t3,
-        typename access_traits<T4>::parameter_type t4,
-        typename access_traits<T5>::parameter_type t5,
-        typename access_traits<T6>::parameter_type t6,
-        typename access_traits<T7>::parameter_type t7)
-    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(),
-                detail::cnull()) {}
-
-  tuple(typename access_traits<T0>::parameter_type t0,
-        typename access_traits<T1>::parameter_type t1,
-        typename access_traits<T2>::parameter_type t2,
-        typename access_traits<T3>::parameter_type t3,
-        typename access_traits<T4>::parameter_type t4,
-        typename access_traits<T5>::parameter_type t5,
-        typename access_traits<T6>::parameter_type t6,
-        typename access_traits<T7>::parameter_type t7,
-        typename access_traits<T8>::parameter_type t8)
-    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, detail::cnull()) {}
-
-  tuple(typename access_traits<T0>::parameter_type t0,
-        typename access_traits<T1>::parameter_type t1,
-        typename access_traits<T2>::parameter_type t2,
-        typename access_traits<T3>::parameter_type t3,
-        typename access_traits<T4>::parameter_type t4,
-        typename access_traits<T5>::parameter_type t5,
-        typename access_traits<T6>::parameter_type t6,
-        typename access_traits<T7>::parameter_type t7,
-        typename access_traits<T8>::parameter_type t8,
-        typename access_traits<T9>::parameter_type t9)
-    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}
-
-
-  template<class U1, class U2>
-  tuple(const cons<U1, U2>& p) : inherited(p) {}
-
-  template <class U1, class U2>
-  tuple& operator=(const cons<U1, U2>& k) {
-    inherited::operator=(k);
-    return *this;
-  }
-
-  template <class U1, class U2>
-  tuple& operator=(const std::pair<U1, U2>& k) {
-    BOOST_STATIC_ASSERT(length<tuple>::value == 2);// check_length = 2
-    this->head = k.first;
-    this->tail.head = k.second;
-    return *this;
-  }
-
-};
-
-// The empty tuple
-template <>
-class tuple<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>  :
-  public null_type
-{
-public:
-  typedef null_type inherited;
-};
-
-
-// Swallows any assignment   (by Doug Gregor)
-namespace detail {
-
-struct swallow_assign;
-typedef void (detail::swallow_assign::*ignore_t)();
-struct swallow_assign {
-  swallow_assign(ignore_t(*)(ignore_t)) {}
-  template<typename T>
-  swallow_assign const& operator=(const T&) const {
-    return *this;
-  }
-};
-
-
-} // namespace detail
-
-// "ignore" allows tuple positions to be ignored when using "tie".
-inline detail::ignore_t ignore(detail::ignore_t) { return 0; }
-
-// ---------------------------------------------------------------------------
-// The call_traits for make_tuple
-// Honours the reference_wrapper class.
-
-// Must be instantiated with plain or const plain types (not with references)
-
-// from template<class T> foo(const T& t) : make_tuple_traits<const T>::type
-// from template<class T> foo(T& t) : make_tuple_traits<T>::type
-
-// Conversions:
-// T -> T,
-// references -> compile_time_error
-// reference_wrapper<T> -> T&
-// const reference_wrapper<T> -> T&
-// array -> const ref array
-
-
-template<class T>
-struct make_tuple_traits {
-  typedef T type;
-
-  // commented away, see below  (JJ)
-  //  typedef typename IF<
-  //  boost::is_function<T>::value,
-  //  T&,
-  //  T>::RET type;
-
-};
-
-// The is_function test was there originally for plain function types,
-// which can't be stored as such (we must either store them as references or
-// pointers). Such a type could be formed if make_tuple was called with a
-// reference to a function.
-// But this would mean that a const qualified function type was formed in
-// the make_tuple function and hence make_tuple can't take a function
-// reference as a parameter, and thus T can't be a function type.
-// So is_function test was removed.
-// (14.8.3. says that type deduction fails if a cv-qualified function type
-// is created. (It only applies for the case of explicitly specifying template
-// args, though?)) (JJ)
-
-template<class T>
-struct make_tuple_traits<T&> {
-  typedef typename
-     detail::generate_error<T&>::
-       do_not_use_with_reference_type error;
-};
-
-// Arrays can't be stored as plain types; convert them to references.
-// All arrays are converted to const. This is because make_tuple takes its
-// parameters as const T& and thus the knowledge of the potential
-// non-constness of actual argument is lost.
-template<class T, int n>  struct make_tuple_traits <T[n]> {
-  typedef const T (&type)[n];
-};
-
-template<class T, int n>
-struct make_tuple_traits<const T[n]> {
-  typedef const T (&type)[n];
-};
-
-template<class T, int n>  struct make_tuple_traits<volatile T[n]> {
-  typedef const volatile T (&type)[n];
-};
-
-template<class T, int n>
-struct make_tuple_traits<const volatile T[n]> {
-  typedef const volatile T (&type)[n];
-};
-
-template<class T>
-struct make_tuple_traits<reference_wrapper<T> >{
-  typedef T& type;
-};
-
-template<class T>
-struct make_tuple_traits<const reference_wrapper<T> >{
-  typedef T& type;
-};
-
-template<>
-struct make_tuple_traits<detail::ignore_t(detail::ignore_t)> {
-  typedef detail::swallow_assign type;
-};
-
-
-
-namespace detail {
-
-// a helper traits to make the make_tuple functions shorter (Vesa Karvonen's
-// suggestion)
-template <
-  class T0 = null_type, class T1 = null_type, class T2 = null_type,
-  class T3 = null_type, class T4 = null_type, class T5 = null_type,
-  class T6 = null_type, class T7 = null_type, class T8 = null_type,
-  class T9 = null_type
->
-struct make_tuple_mapper {
-  typedef
-    tuple<typename make_tuple_traits<T0>::type,
-          typename make_tuple_traits<T1>::type,
-          typename make_tuple_traits<T2>::type,
-          typename make_tuple_traits<T3>::type,
-          typename make_tuple_traits<T4>::type,
-          typename make_tuple_traits<T5>::type,
-          typename make_tuple_traits<T6>::type,
-          typename make_tuple_traits<T7>::type,
-          typename make_tuple_traits<T8>::type,
-          typename make_tuple_traits<T9>::type> type;
-};
-
-} // end detail
-
-// -make_tuple function templates -----------------------------------
-inline tuple<> make_tuple() {
-  return tuple<>();
-}
-
-template<class T0>
-inline typename detail::make_tuple_mapper<T0>::type
-make_tuple(const T0& t0) {
-  typedef typename detail::make_tuple_mapper<T0>::type t;
-  return t(t0);
-}
-
-template<class T0, class T1>
-inline typename detail::make_tuple_mapper<T0, T1>::type
-make_tuple(const T0& t0, const T1& t1) {
-  typedef typename detail::make_tuple_mapper<T0, T1>::type t;
-  return t(t0, t1);
-}
-
-template<class T0, class T1, class T2>
-inline typename detail::make_tuple_mapper<T0, T1, T2>::type
-make_tuple(const T0& t0, const T1& t1, const T2& t2) {
-  typedef typename detail::make_tuple_mapper<T0, T1, T2>::type t;
-  return t(t0, t1, t2);
-}
-
-template<class T0, class T1, class T2, class T3>
-inline typename detail::make_tuple_mapper<T0, T1, T2, T3>::type
-make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) {
-  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3>::type t;
-  return t(t0, t1, t2, t3);
-}
-
-template<class T0, class T1, class T2, class T3, class T4>
-inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type
-make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
-                  const T4& t4) {
-  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type t;
-  return t(t0, t1, t2, t3, t4);
-}
-
-template<class T0, class T1, class T2, class T3, class T4, class T5>
-inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
-make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
-                  const T4& t4, const T5& t5) {
-  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type t;
-  return t(t0, t1, t2, t3, t4, t5);
-}
-
-template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
-inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::type
-make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
-                  const T4& t4, const T5& t5, const T6& t6) {
-  typedef typename detail::make_tuple_mapper
-           <T0, T1, T2, T3, T4, T5, T6>::type t;
-  return t(t0, t1, t2, t3, t4, t5, t6);
-}
-
-template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
-         class T7>
-inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
-make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
-                  const T4& t4, const T5& t5, const T6& t6, const T7& t7) {
-  typedef typename detail::make_tuple_mapper
-           <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
-  return t(t0, t1, t2, t3, t4, t5, t6, t7);
-}
-
-template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
-         class T7, class T8>
-inline typename detail::make_tuple_mapper
-  <T0, T1, T2, T3, T4, T5, T6, T7, T8>::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,
-                  const T8& t8) {
-  typedef typename detail::make_tuple_mapper
-           <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
-  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
-}
-
-template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
-         class T7, class T8, class T9>
-inline typename detail::make_tuple_mapper
-  <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::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,
-                  const T8& t8, const T9& t9) {
-  typedef typename detail::make_tuple_mapper
-           <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
-  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
-}
-
-namespace detail {
-
-template<class T>
-struct tie_traits {
-  typedef T& type;
-};
-
-template<>
-struct tie_traits<ignore_t(ignore_t)> {
-  typedef swallow_assign type;
-};
-
-template<>
-struct tie_traits<void> {
-  typedef null_type type;
-};
-
-template <
-  class T0 = void, class T1 = void, class T2 = void,
-  class T3 = void, class T4 = void, class T5 = void,
-  class T6 = void, class T7 = void, class T8 = void,
-  class T9 = void
->
-struct tie_mapper {
-  typedef
-    tuple<typename tie_traits<T0>::type,
-          typename tie_traits<T1>::type,
-          typename tie_traits<T2>::type,
-          typename tie_traits<T3>::type,
-          typename tie_traits<T4>::type,
-          typename tie_traits<T5>::type,
-          typename tie_traits<T6>::type,
-          typename tie_traits<T7>::type,
-          typename tie_traits<T8>::type,
-          typename tie_traits<T9>::type> type;
-};
-
-}
-
-// Tie function templates -------------------------------------------------
-template<class T0>
-inline typename detail::tie_mapper<T0>::type
-tie(T0& t0) {
-  typedef typename detail::tie_mapper<T0>::type t;
-  return t(t0);
-}
-
-template<class T0, class T1>
-inline typename detail::tie_mapper<T0, T1>::type
-tie(T0& t0, T1& t1) {
-  typedef typename detail::tie_mapper<T0, T1>::type t;
-  return t(t0, t1);
-}
-
-template<class T0, class T1, class T2>
-inline typename detail::tie_mapper<T0, T1, T2>::type
-tie(T0& t0, T1& t1, T2& t2) {
-  typedef typename detail::tie_mapper<T0, T1, T2>::type t;
-  return t(t0, t1, t2);
-}
-
-template<class T0, class T1, class T2, class T3>
-inline typename detail::tie_mapper<T0, T1, T2, T3>::type
-tie(T0& t0, T1& t1, T2& t2, T3& t3) {
-  typedef typename detail::tie_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::tie_mapper<T0, T1, T2, T3, T4>::type
-tie(T0& t0, T1& t1, T2& t2, T3& t3,
-                  T4& t4) {
-  typedef typename detail::tie_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::tie_mapper<T0, T1, T2, T3, T4, T5>::type
-tie(T0& t0, T1& t1, T2& t2, T3& t3,
-                  T4& t4, T5& t5) {
-  typedef typename detail::tie_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::tie_mapper<T0, T1, T2, T3, T4, T5, T6>::type
-tie(T0& t0, T1& t1, T2& t2, T3& t3,
-                  T4& t4, T5& t5, T6& t6) {
-  typedef typename detail::tie_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,
-         class T7>
-inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
-tie(T0& t0, T1& t1, T2& t2, T3& t3,
-                  T4& t4, T5& t5, T6& t6, T7& t7) {
-  typedef typename detail::tie_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,
-         class T7, class T8>
-inline typename detail::tie_mapper
-  <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
-tie(T0& t0, T1& t1, T2& t2, T3& t3,
-                  T4& t4, T5& t5, T6& t6, T7& t7,
-                  T8& t8) {
-  typedef typename detail::tie_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,
-         class T7, class T8, class T9>
-inline typename detail::tie_mapper
-  <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
-tie(T0& t0, T1& t1, T2& t2, T3& t3,
-                  T4& t4, T5& t5, T6& t6, T7& t7,
-                  T8& t8, T9& t9) {
-  typedef typename detail::tie_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);
-}
-
-template <class T0, class T1, class T2, class T3, class T4,
-          class T5, class T6, class T7, class T8, class T9>
-void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
-          tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs);
-inline void swap(null_type&, null_type&) {}
-template<class HH>
-inline void swap(cons<HH, null_type>& lhs, cons<HH, null_type>& rhs) {
-  ::boost::swap(lhs.head, rhs.head);
-}
-template<class HH, class TT>
-inline void swap(cons<HH, TT>& lhs, cons<HH, TT>& rhs) {
-  ::boost::swap(lhs.head, rhs.head);
-  ::boost::tuples::swap(lhs.tail, rhs.tail);
-}
-template <class T0, class T1, class T2, class T3, class T4,
-          class T5, class T6, class T7, class T8, class T9>
-inline void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
-          tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs) {
-  typedef tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> tuple_type;
-  typedef typename tuple_type::inherited base;
-  ::boost::tuples::swap(static_cast<base&>(lhs), static_cast<base&>(rhs));
-}
-
-} // end of namespace tuples
-} // end of namespace boost
-
-
-#if BOOST_GCC >= 40700
-#pragma GCC diagnostic pop
-#endif
-
-
-#endif // BOOST_TUPLE_BASIC_HPP
-
-
--- a/include/boost/tuple/tuple.hpp
+++ b/include/boost/tuple/tuple.hpp
@ -1,67 +0,0 @@
-//  tuple.hpp - Boost Tuple Library --------------------------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// For more information, see http://www.boost.org
-
-// ----------------------------------------------------------------- 
-
-#ifndef BOOST_TUPLE_HPP
-#define BOOST_TUPLE_HPP
-
-#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
-// Work around a compiler bug.
-// boost::python::tuple has to be seen by the compiler before the
-// boost::tuple class template.
-namespace boost { namespace python { class tuple; }}
-#endif
-
-#include "boost/config.hpp"
-#include "boost/static_assert.hpp"
-
-// other compilers
-#include "boost/ref.hpp"
-#include "boost/tuple/detail/tuple_basic.hpp"
-
-
-namespace boost {    
-
-using tuples::tuple;
-using tuples::make_tuple;
-using tuples::tie;
-#if !defined(BOOST_NO_USING_TEMPLATE)
-using tuples::get;
-#else
-//
-// 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);
-}
-
-#endif // BOOST_NO_USING_TEMPLATE
-   
-} // end namespace boost
-
-
-#endif // BOOST_TUPLE_HPP
--- a/include/boost/tuple/tuple_comparison.hpp
+++ b/include/boost/tuple/tuple_comparison.hpp
@ -1,175 +0,0 @@
-// tuple_comparison.hpp -----------------------------------------------------
-//  
-// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-// 
-// For more information, see http://www.boost.org
-// 
-// (The idea and first impl. of comparison operators was from Doug Gregor)
-
-// ----------------------------------------------------------------- 
-
-#ifndef BOOST_TUPLE_COMPARISON_HPP
-#define BOOST_TUPLE_COMPARISON_HPP
-
-#include "boost/tuple/tuple.hpp"
-
-// -------------------------------------------------------------
-// equality and comparison operators 
-//
-// == and != compare tuples elementwise
-// <, >, <= and >= use lexicographical ordering
-//
-// Any operator between tuples of different length fails at compile time
-// No dependencies between operators are assumed 
-// (i.e. !(a<b)  does not imply a>=b, a!=b does not imply a==b etc.
-// so any weirdnesses of elementary operators are respected).
-//
-// -------------------------------------------------------------
-
-
-namespace boost {
-namespace tuples {
-
-inline bool operator==(const null_type&, const null_type&) { return true; }
-inline bool operator>=(const null_type&, const null_type&) { return true; }
-inline bool operator<=(const null_type&, const null_type&) { return true; }
-inline bool operator!=(const null_type&, const null_type&) { return false; }
-inline bool operator<(const null_type&, const null_type&) { return false; }
-inline bool operator>(const null_type&, const null_type&) { return false; }
-
-
-namespace detail {
-  // comparison operators check statically the length of its operands and
-  // delegate the comparing task to the following functions. Hence
-  // the static check is only made once (should help the compiler).  
-  // These functions assume tuples to be of the same length.
-
-
-template<class T1, class T2>
-inline bool eq(const T1& lhs, const T2& rhs) {
-  return lhs.get_head() == rhs.get_head() &&
-         eq(lhs.get_tail(), rhs.get_tail());
-}
-template<>
-inline bool eq<null_type,null_type>(const null_type&, const null_type&) { return true; }
-
-template<class T1, class T2>
-inline bool neq(const T1& lhs, const T2& rhs) {
-  return lhs.get_head() != rhs.get_head()  ||
-         neq(lhs.get_tail(), rhs.get_tail());
-}
-template<>
-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) {
-  return lhs.get_head() < rhs.get_head()  ||
-          ( !(rhs.get_head() < lhs.get_head()) &&
-            lt(lhs.get_tail(), rhs.get_tail()));
-}
-template<>
-inline bool lt<null_type,null_type>(const null_type&, const null_type&) { return false; }
-
-template<class T1, class T2>
-inline bool gt(const T1& lhs, const T2& rhs) {
-  return lhs.get_head() > rhs.get_head()  ||
-          ( !(rhs.get_head() > lhs.get_head()) &&
-            gt(lhs.get_tail(), rhs.get_tail()));
-}
-template<>
-inline bool gt<null_type,null_type>(const null_type&, const null_type&) { return false; }
-
-template<class T1, class T2>
-inline bool lte(const T1& lhs, const T2& rhs) {
-  return lhs.get_head() <= rhs.get_head()  &&
-          ( !(rhs.get_head() <= lhs.get_head()) ||
-            lte(lhs.get_tail(), rhs.get_tail()));
-}
-template<>
-inline bool lte<null_type,null_type>(const null_type&, const null_type&) { return true; }
-
-template<class T1, class T2>
-inline bool gte(const T1& lhs, const T2& rhs) {
-  return lhs.get_head() >= rhs.get_head()  &&
-          ( !(rhs.get_head() >= lhs.get_head()) ||
-            gte(lhs.get_tail(), rhs.get_tail()));
-}
-template<>
-inline bool gte<null_type,null_type>(const null_type&, const null_type&) { return true; }
-
-} // end of namespace detail
-
-
-// equal ----
-
-template<class T1, class T2, class S1, class S2>
-inline bool operator==(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
-{
-  // check that tuple lengths are equal
-  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
-
-  return  detail::eq(lhs, rhs);
-}
-
-// not equal -----
-
-template<class T1, class T2, class S1, class S2>
-inline bool operator!=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
-{
-
-  // check that tuple lengths are equal
-  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
-
-  return detail::neq(lhs, rhs);
-}
-
-// <
-template<class T1, class T2, class S1, class S2>
-inline bool operator<(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
-{
-  // check that tuple lengths are equal
-  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
-
-  return detail::lt(lhs, rhs);
-}
-
-// >
-template<class T1, class T2, class S1, class S2>
-inline bool operator>(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
-{
-  // check that tuple lengths are equal
-  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
-
-  return detail::gt(lhs, rhs);
-}
-
-// <=
-template<class T1, class T2, class S1, class S2>
-inline bool operator<=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
-{
-  // check that tuple lengths are equal
-  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
-
-  return detail::lte(lhs, rhs);
-}
-
-// >=
-template<class T1, class T2, class S1, class S2>
-inline bool operator>=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
-{
-  // check that tuple lengths are equal
-  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
-
-  return detail::gte(lhs, rhs);
-}
-
-} // end of namespace tuples
-} // end of namespace boost
-
-
-#endif // BOOST_TUPLE_COMPARISON_HPP
--- a/include/boost/tuple/tuple_io.hpp
+++ b/include/boost/tuple/tuple_io.hpp
@ -1,341 +0,0 @@
-// tuple_io.hpp --------------------------------------------------------------
-
-// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//               2001 Gary Powell (gary.powell@sierra.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-// For more information, see http://www.boost.org 
-
-// ----------------------------------------------------------------------------
-
-#ifndef BOOST_TUPLE_IO_HPP
-#define BOOST_TUPLE_IO_HPP
-
-#include <istream>
-#include <ostream>
-
-#include <sstream>
-
-#include "boost/tuple/tuple.hpp"
-
-// This is ugly: one should be using twoargument isspace since whitspace can
-// be locale dependent, in theory at least.
-// not all libraries implement have the two-arg version, so we need to 
-// use the one-arg one, which one should get with <cctype> but there seem
-// to be exceptions to this.
-
-#if !defined (BOOST_NO_STD_LOCALE)
-
-#include <locale> // for two-arg isspace
-
-#else 
-
-#include <cctype> // for one-arg (old) isspace 
-#include <ctype.h> // Metrowerks does not find one-arg isspace from cctype
-
-#endif
-
-namespace boost {
-namespace tuples {
-
-namespace detail {
-
-class format_info {
-public:   
-
-   enum manipulator_type { open, close, delimiter };
-   BOOST_STATIC_CONSTANT(int, number_of_manipulators = delimiter + 1);
-private:
-   
-   static int get_stream_index (int m)
-   {
-     static const int stream_index[number_of_manipulators]
-        = { std::ios::xalloc(), std::ios::xalloc(), std::ios::xalloc() };
-
-     return stream_index[m];
-   }
-
-   format_info(const format_info&);
-   format_info();   
-
-
-public:
-
-   template<class CharType, class CharTrait>
-   static CharType get_manipulator(std::basic_ios<CharType, CharTrait>& i, 
-                                   manipulator_type m) {
-     // The manipulators are stored as long.
-     // A valid instanitation of basic_stream allows CharType to be any POD,
-     // hence, the static_cast may fail (it fails if long is not convertible 
-     // to CharType
-     CharType c = static_cast<CharType>(i.iword(get_stream_index(m)) ); 
-     // parentheses and space are the default manipulators
-     if (!c) {
-       switch(m) {
-         case detail::format_info::open :  c = i.widen('('); break;
-         case detail::format_info::close : c = i.widen(')'); break;
-         case detail::format_info::delimiter : c = i.widen(' '); break;
-       }
-     }
-     return c;
-   }
-
-
-   template<class CharType, class CharTrait>
-   static void set_manipulator(std::basic_ios<CharType, CharTrait>& i, 
-                               manipulator_type m, CharType c) {
-     // The manipulators are stored as long.
-     // A valid instanitation of basic_stream allows CharType to be any POD,
-     // hence, the static_cast may fail (it fails if CharType is not 
-     // convertible long.
-      i.iword(get_stream_index(m)) = static_cast<long>(c);
-   }
-};
-
-} // end of namespace detail
- 
-template<class CharType>    
-class tuple_manipulator {
-  const detail::format_info::manipulator_type mt;
-  CharType f_c;
-public:
-  explicit tuple_manipulator(detail::format_info::manipulator_type m, 
-                             const char c = 0)
-     : mt(m), f_c(c) {}
-  
-   template<class CharTrait>
-  void set(std::basic_ios<CharType, CharTrait> &io) const {
-     detail::format_info::set_manipulator(io, mt, f_c);
-  }
-};
-
-
-template<class CharType, class CharTrait>
-inline std::basic_ostream<CharType, CharTrait>&
-operator<<(std::basic_ostream<CharType, CharTrait>& o, const tuple_manipulator<CharType>& m) {
-  m.set(o);
-  return o;
-}
-
-template<class CharType, class CharTrait>
-inline std::basic_istream<CharType, CharTrait>&
-operator>>(std::basic_istream<CharType, CharTrait>& i, const tuple_manipulator<CharType>& m) {
-  m.set(i);
-  return i;
-}
-
-   
-template<class CharType>
-inline tuple_manipulator<CharType> set_open(const CharType c) {
-   return tuple_manipulator<CharType>(detail::format_info::open, c);
-}
-
-template<class CharType>
-inline tuple_manipulator<CharType> set_close(const CharType c) {
-   return tuple_manipulator<CharType>(detail::format_info::close, c);
-}
-
-template<class CharType>
-inline tuple_manipulator<CharType> set_delimiter(const CharType c) {
-   return tuple_manipulator<CharType>(detail::format_info::delimiter, c);
-}
-
-
-
-   
-   
-// -------------------------------------------------------------
-// printing tuples to ostream in format (a b c)
-// parentheses and space are defaults, but can be overriden with manipulators
-// set_open, set_close and set_delimiter
-   
-namespace detail {
-
-// Note: The order of the print functions is critical 
-// to let a conforming compiler  find and select the correct one.
-
-
-template<class CharType, class CharTrait, class T1>
-inline std::basic_ostream<CharType, CharTrait>& 
-print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, null_type>& t) {
-  return o << t.head;
-}
-
- 
-template<class CharType, class CharTrait>
-inline std::basic_ostream<CharType, CharTrait>& 
-print(std::basic_ostream<CharType, CharTrait>& o, const null_type&) { 
-  return o; 
-}
-
-template<class CharType, class CharTrait, class T1, class T2>
-inline std::basic_ostream<CharType, CharTrait>& 
-print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, T2>& t) {
-  
-  const CharType d = format_info::get_manipulator(o, format_info::delimiter);
-   
-  o << t.head;
-
-  o << d;
-
-  return print(o, t.tail);
-}
-
-template<class CharT, class Traits, class T>
-inline bool handle_width(std::basic_ostream<CharT, Traits>& o, const T& t) {
-    std::streamsize width = o.width();
-    if(width == 0) return false;
-
-    std::basic_ostringstream<CharT, Traits> ss;
-
-    ss.copyfmt(o);
-    ss.tie(0);
-    ss.width(0);
-
-    ss << t;
-    o << ss.str();
-
-    return true;
-}
-
-
-} // namespace detail
-
-
-template<class CharType, class CharTrait>
-inline std::basic_ostream<CharType, CharTrait>& 
-operator<<(std::basic_ostream<CharType, CharTrait>& o, 
-           const null_type& t) {
-  if (!o.good() ) return o;
-  if (detail::handle_width(o, t)) return o;
- 
-  const CharType l = 
-    detail::format_info::get_manipulator(o, detail::format_info::open);
-  const CharType r = 
-    detail::format_info::get_manipulator(o, detail::format_info::close);
-   
-  o << l;
-  o << r;
-
-  return o;
-}
-
-template<class CharType, class CharTrait, class T1, class T2>
-inline std::basic_ostream<CharType, CharTrait>& 
-operator<<(std::basic_ostream<CharType, CharTrait>& o, 
-           const cons<T1, T2>& t) {
-  if (!o.good() ) return o;
-  if (detail::handle_width(o, t)) return o;
- 
-  const CharType l = 
-    detail::format_info::get_manipulator(o, detail::format_info::open);
-  const CharType r = 
-    detail::format_info::get_manipulator(o, detail::format_info::close);
-   
-  o << l;   
-
-  detail::print(o, t);  
-
-  o << r;
-
-  return o;
-}
-
-   
-// -------------------------------------------------------------
-// input stream operators
-
-namespace detail {
-
-
-template<class CharType, class CharTrait>
-inline std::basic_istream<CharType, CharTrait>& 
-extract_and_check_delimiter(
-  std::basic_istream<CharType, CharTrait> &is, format_info::manipulator_type del)
-{
-  const CharType d = format_info::get_manipulator(is, del);
-
-#if defined (BOOST_NO_STD_LOCALE)
-  const bool is_delimiter = !isspace(d);
-#elif defined ( __BORLANDC__ )
-  const bool is_delimiter = !std::use_facet< std::ctype< CharType > >
-    (is.getloc() ).is( std::ctype_base::space, d);
-#else
-  const bool is_delimiter = (!std::isspace(d, is.getloc()) );            
-#endif
-
-  CharType c;
-  if (is_delimiter) { 
-    is >> c;
-    if (is.good() && c!=d) { 
-      is.setstate(std::ios::failbit);
-    }
-  } else {
-    is >> std::ws;
-  }
-  return is;
-}
-
-   
-template<class CharType, class CharTrait, class T1>
-inline  std::basic_istream<CharType, CharTrait> & 
-read (std::basic_istream<CharType, CharTrait> &is, cons<T1, null_type>& t1) {
-
-  if (!is.good()) return is;   
-   
-  return is >> t1.head; 
-}
-
-template<class CharType, class CharTrait, class T1, class T2>
-inline std::basic_istream<CharType, CharTrait>& 
-read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) {
-
-  if (!is.good()) return is;
-   
-  is >> t1.head;
-
-
-  extract_and_check_delimiter(is, format_info::delimiter);
-
-  return read(is, t1.tail);
-}
-
-} // end namespace detail
-
-
-template<class CharType, class CharTrait>
-inline std::basic_istream<CharType, CharTrait>& 
-operator>>(std::basic_istream<CharType, CharTrait> &is, null_type&) {
-
-  if (!is.good() ) return is;
-
-  detail::extract_and_check_delimiter(is, detail::format_info::open);
-  detail::extract_and_check_delimiter(is, detail::format_info::close);
-
-  return is;
-}
-
-template<class CharType, class CharTrait, class T1, class T2>
-inline std::basic_istream<CharType, CharTrait>& 
-operator>>(std::basic_istream<CharType, CharTrait>& is, cons<T1, T2>& t1) {
-
-  if (!is.good() ) return is;
-
-  detail::extract_and_check_delimiter(is, detail::format_info::open);
-                      
-  detail::read(is, t1);
-   
-  detail::extract_and_check_delimiter(is, detail::format_info::close);
-
-  return is;
-}
-
-
-} // end of namespace tuples
-} // end of namespace boost
-
-#endif // BOOST_TUPLE_IO_HPP
-
-
--- a/index.html
+++ b/index.html
@ -3,11 +3,6 @@
 <meta http-equiv="refresh" content="0; URL=doc/tuple_users_guide.html">
 </head>
 <body>
-Automatic redirection failed, please go to <a href="doc/tuple_users_guide.html">doc/tuple_users_guide.html</a> 
-&nbsp;<hr>
-<p><EFBFBD> Copyright Beman Dawes, 2001</p>
-<p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
-file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
-at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
+Automatic redirection failed, please go to <a href="doc/tuple_users_guide.html">doc/tuple_users_guide.html</a>
 </body>
-</html>
+</html>
--- a/test/Jamfile
+++ b/test/Jamfile
@ -1,8 +1,20 @@
+subproject libs/tuple/test ;

-project : requirements <library>/boost/test//boost_test_exec_monitor ;
+unit-test tuple_test_bench
+    : tuple_test_bench.cpp
+      <lib>../../test/build/boost_test_exec_monitor
+    : <sysinclude>$(BOOST_ROOT)
+    ;
+
+unit-test io_test
+    : io_test.cpp
+      <lib>../../test/build/boost_test_exec_monitor
+    : <sysinclude>$(BOOST_ROOT)
+    ;
+
+unit-test another_tuple_test_bench
+    : another_tuple_test_bench.cpp
+      <lib>../../test/build/boost_test_exec_monitor
+    : <sysinclude>$(BOOST_ROOT)
+    ;

-test-suite tuple : 
-    [ run tuple_test_bench.cpp ]
-    [ run io_test.cpp ]
-    [ run another_tuple_test_bench.cpp ]
-    ;
--- a/test/another_tuple_test_bench.cpp
+++ b/test/another_tuple_test_bench.cpp
@ -1,4 +1,4 @@
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@ -23,6 +23,7 @@
 #include <string>
 #include <utility>

+using namespace std;
 using namespace boost;
 using namespace boost::tuples;

--- a/test/io_test.cpp
+++ b/test/io_test.cpp
@ -1,4 +1,4 @@
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@ -20,7 +20,6 @@
 #include <iterator>
 #include <algorithm>
 #include <string>
-#include <iomanip>

 #if defined BOOST_NO_STRINGSTREAM
 #include <strstream>
@ -28,14 +27,15 @@
 #include <sstream>
 #endif

+using namespace std;
 using namespace boost;

 #if defined BOOST_NO_STRINGSTREAM
-typedef std::ostrstream useThisOStringStream;
-typedef std::istrstream useThisIStringStream;
+typedef ostrstream useThisOStringStream;
+typedef istrstream useThisIStringStream;
 #else
-typedef std::ostringstream useThisOStringStream;
-typedef std::istringstream useThisIStringStream;
+typedef ostringstream useThisOStringStream;
+typedef istringstream useThisIStringStream;
 #endif

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

  {
  useThisOStringStream os2;
@ -62,76 +62,48 @@ int test_main(int argc, char * argv[] ) {
  os2 << set_delimiter(':');
 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  os2 << make_tuple("TUPU", "HUPU", "LUPU", 4.5);
-  BOOST_CHECK (os2.str() == std::string("(TUPU:HUPU:LUPU:4.5)") );
+  BOOST_TEST (os2.str() == std::string("(TUPU:HUPU:LUPU:4.5)") );
 #endif
  }

  // The format is still [a, b, c] for os1
  os1 << make_tuple(1, 2, 3);
-  BOOST_CHECK (os1.str() == std::string("[1,2,3][1,2,3]") );
+  BOOST_TEST (os1.str() == std::string("[1,2,3][1,2,3]") );

-  // check empty tuple.
-  useThisOStringStream os3;
-  os3 << make_tuple();
-  BOOST_CHECK (os3.str() == std::string("()") );
-  os3 << set_open('[');
-  os3 << set_close(']');
-  os3 << make_tuple();
-  BOOST_CHECK (os3.str() == std::string("()[]") );
-  
-  // check width
-  useThisOStringStream os4;
-  os4 << std::setw(10) << make_tuple(1, 2, 3);
-  BOOST_CHECK (os4.str() == std::string("   (1 2 3)") );
-
-  std::ofstream tmp("temp.tmp");
+  ofstream tmp("temp.tmp");

 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  tmp << make_tuple("One", "Two", 3);
 #endif   
  tmp << set_delimiter(':');
-  tmp << make_tuple(1000, 2000, 3000) << std::endl;
+  tmp << make_tuple(1000, 2000, 3000) << endl;

  tmp.close();
  
  // When teading tuples from a stream, manipulators must be set correctly:
-  std::ifstream tmp3("temp.tmp");
-  tuple<std::string, std::string, int> j;
+  ifstream tmp3("temp.tmp");
+  tuple<string, string, int> j;

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


  // reading tuple<int, int, int> in format (a b c); 
-  useThisIStringStream is1("(100 200 300)"); 
+  useThisIStringStream is("(100 200 300)"); 
   
-  tuple<int, int, int> ti1; 
-  BOOST_CHECK(bool(is1 >> ti1));
-  BOOST_CHECK(ti1 == make_tuple(100, 200, 300));
-
-  useThisIStringStream is2("()");
-  tuple<> ti2;
-  BOOST_CHECK(bool(is2 >> ti2));
-  useThisIStringStream is3("[]");
-  is3 >> set_open('[');
-  is3 >> set_close(']');
-  BOOST_CHECK(bool(is3 >> ti2));
-
-  // Make sure that whitespace between elements
-  // is skipped.
-  useThisIStringStream is4("(100 200 300)"); 
+  tuple<int, int, int> ti; 
+  BOOST_TEST(bool(is >> ti));
+  BOOST_TEST(ti == make_tuple(100, 200, 300));
   
-  BOOST_CHECK(bool(is4 >> std::noskipws >> ti1));
-  BOOST_CHECK(ti1 == make_tuple(100, 200, 300));

  // Note that strings are problematic:
  // writing a tuple on a stream and reading it back doesn't work in
--- a/test/tuple_test_bench.cpp
+++ b/test/tuple_test_bench.cpp
@ -1,4 +1,4 @@
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@ -21,6 +21,7 @@
 #include <string>
 #include <utility>

+using namespace std;
 using namespace boost;

 // ----------------------------------------------------------------------------
@ -106,32 +107,32 @@ construction_test()
  // MSVC 6.0 just cannot find get without the namespace qualifier

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

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

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

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

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

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

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

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

  dummy(
    tuple<no_def_constructor, no_def_constructor, no_def_constructor>(
@ -174,27 +175,27 @@ void element_access_test()
  int i  = get<0>(t);
  int i2 = get<3>(t);

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

  int j  = get<0>(ct);
-  BOOST_CHECK(j == 1);
+  BOOST_TEST(j == 1);
   
  get<0>(t) = 5;
-  BOOST_CHECK(t.head == 5);
+  BOOST_TEST(t.head == 5);
   
  //  get<0>(ct) = 5; // can't assign to const

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

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

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

  BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<0, tuple<int, float> >::type>::value != true));
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
@ -223,13 +224,13 @@ copy_test()
  tuple<int, char> t1(4, 'a');
  tuple<int, char> t2(5, 'b');
  t2 = t1;
-  BOOST_CHECK(get<0>(t1) == get<0>(t2));
-  BOOST_CHECK(get<1>(t1) == get<1>(t2));
+  BOOST_TEST(get<0>(t1) == get<0>(t2));
+  BOOST_TEST(get<1>(t1) == get<1>(t2));

  tuple<long, std::string> t3(2, "a");
  t3 = t1;
-  BOOST_CHECK((double)get<0>(t1) == get<0>(t3));
-  BOOST_CHECK(get<1>(t1) == 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
@ -241,9 +242,9 @@ copy_test()
  int i; char c; double d;
  tie(i, c, d) = make_tuple(1, 'a', 5.5);
  
-  BOOST_CHECK(i==1);
-  BOOST_CHECK(c=='a');
-  BOOST_CHECK(d>5.4 && d<5.6);
+  BOOST_TEST(i==1);
+  BOOST_TEST(c=='a');
+  BOOST_TEST(d>5.4 && d<5.6);
 }

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

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

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

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


    A a = A(); B b;
@ -287,7 +288,7 @@ make_tuple_test()
    make_tuple(boost::ref(ca));
     
 // the result of make_tuple is assignable:
-   BOOST_CHECK(make_tuple(2, 4, 6) == 
+   BOOST_TEST(make_tuple(2, 4, 6) == 
             (make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));

 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
@ -335,19 +336,19 @@ tie_test()
  foo c(5);

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

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

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

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

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


@ -387,14 +388,14 @@ ordering_test()
  tuple<int, float> t1(4, 3.3f);
  tuple<short, float> t2(5, 3.3f);
  tuple<long, double> t3(5, 4.4);
-  BOOST_CHECK(t1 < t2);
-  BOOST_CHECK(t1 <= t2);
-  BOOST_CHECK(t2 > t1);
-  BOOST_CHECK(t2 >= t1);
-  BOOST_CHECK(t2 < t3);
-  BOOST_CHECK(t2 <= t3);
-  BOOST_CHECK(t3 > t2);
-  BOOST_CHECK(t3 >= t2);
+  BOOST_TEST(t1 < t2);
+  BOOST_TEST(t1 <= t2);
+  BOOST_TEST(t2 > t1);
+  BOOST_TEST(t2 >= t1);
+  BOOST_TEST(t2 < t3);
+  BOOST_TEST(t2 <= t3);
+  BOOST_TEST(t3 > t2);
+  BOOST_TEST(t3 >= t2);

 }

@ -411,7 +412,7 @@ void cons_test()
  cons<const int, cons<volatile float, null_type> > b(2,a);
  int i = 3;
  cons<int&, cons<const int, cons<volatile float, null_type> > > c(i, b);
-  BOOST_CHECK(make_tuple(3,2,1)==c);
+  BOOST_TEST(make_tuple(3,2,1)==c);

  cons<char, cons<int, cons<float, null_type> > > x;
  dummy(x);
@ -423,8 +424,8 @@ void cons_test()
 void const_tuple_test()
 {
  const tuple<int, float> t1(5, 3.3f);
-  BOOST_CHECK(get<0>(t1) == 5);
-  BOOST_CHECK(get<1>(t1) == 3.3f);
+  BOOST_TEST(get<0>(t1) == 5);
+  BOOST_TEST(get<1>(t1) == 3.3f);
 }

 // ----------------------------------------------------------------------------
@ -445,26 +446,6 @@ void tuple_length_test()

 }

-// ----------------------------------------------------------------------------
-// - testing swap -----------------------------------------------------------
-// ----------------------------------------------------------------------------
-void tuple_swap_test()
-{
-  tuple<int, float, double> t1(1, 2.0f, 3.0), t2(4, 5.0f, 6.0);
-  swap(t1, t2);
-  BOOST_CHECK(get<0>(t1) == 4);
-  BOOST_CHECK(get<1>(t1) == 5.0f);
-  BOOST_CHECK(get<2>(t1) == 6.0);
-  BOOST_CHECK(get<0>(t2) == 1);
-  BOOST_CHECK(get<1>(t2) == 2.0f);
-  BOOST_CHECK(get<2>(t2) == 3.0);
-
-  int i = 1,j = 2;
-  boost::tuple<int&> t3(i), t4(j);
-  swap(t3, t4);
-  BOOST_CHECK(i == 2);
-  BOOST_CHECK(j == 1);
-}



@ -485,7 +466,6 @@ int test_main(int, char *[]) {
  cons_test();
  const_tuple_test();
  tuple_length_test();
-  tuple_swap_test();
  return 0;
 }
Author	SHA1	Message	Date
Hartmut Kaiser	9e5ba40e80	Removed part of the Boost files from the SPIRIT_MINIBOOST branch. [SVN r26362]	2004-11-29 21:25:31 +00:00
nobody	304b94fc86	This commit was manufactured by cvs2svn to create branch 'SPIRIT_MINIBOOST'. [SVN r26343]	2004-11-29 07:29:20 +00:00