This commit was manufactured by cvs2svn to create branch

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

 // Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)

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

 // Outside help:
 // This and that, Gary Powell.
-// Fixed return types for get_head/get_tail 
+// Fixed return types for get_head/get_tail
 // ( and other bugs ) per suggestion of Jens Maurer
 // simplified element type accessors + bug fix  (Jeremy Siek)
-// Several changes/additions according to suggestions by Doug Gregor, 
-// William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Davis,
+// Several changes/additions according to suggestions by Douglas Gregor,
+// William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes,
 // David Abrahams.

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

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

 #include "boost/type_traits/cv_traits.hpp"
 #include "boost/type_traits/function_traits.hpp"
-    
+
+#include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND
+
 namespace boost {
 namespace tuples {

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

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


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

 // tuple_length forward declaration
 template<class T> struct length;
@ -84,18 +81,7 @@ template<class T> struct length;

 namespace detail {

-#ifdef BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
-
-  template<int N> struct workaround_holder {};
-
-#  define BOOST_TUPLE_DUMMY_PARM        , detail::workaround_holder<N>* = 0
-#  define BOOST_TUPLE_SINGLE_DUMMY_PARM detail::workaround_holder<N>* = 0
-#else
-#  define BOOST_TUPLE_DUMMY_PARM
-#  define BOOST_TUPLE_SINGLE_DUMMY_PARM
-#endif
-
-// -- generate error template, referencing to non-existing members of this 
+// -- generate error template, referencing to non-existing members of this
 // template is used to produce compilation errors intentionally
 template<class T>
 class generate_error;
@ -108,23 +94,33 @@ struct get_class {
  template<class RET, class HT, class TT >
  inline static RET get(const cons<HT, TT>& t)
  {
-    return get_class<N-1>::template get<RET>(t.tail);
+#if BOOST_WORKAROUND(__IBMCPP__,==600)
+    // vacpp 6.0 is not very consistent regarding the member template keyword
+    // Here it generates an error when the template keyword is used.
+    return get_class<N-1>::get<RET>(t.tail);
+#else
+    return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
+#endif
  }
  template<class RET, class HT, class TT >
  inline static RET get(cons<HT, TT>& t)
  {
-    return get_class<N-1>::template get<RET>(t.tail);
+#if BOOST_WORKAROUND(__IBMCPP__,==600)
+    return get_class<N-1>::get<RET>(t.tail);
+#else
+    return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
+#endif
  }
 };

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


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

+#ifndef BOOST_NO_CV_SPECIALIZATIONS
+
 template<int N, class T>
 struct element
 {
@ -153,6 +151,76 @@ struct element<0,T>
  typedef typename T::head_type type;
 };

+template<int N, class T>
+struct element<N, const T>
+{
+private:
+  typedef typename T::tail_type Next;
+  typedef typename element<N-1, Next>::type unqualified_type;
+public:
+#if BOOST_WORKAROUND(__BORLANDC__,<0x600)
+  typedef const unqualified_type type;
+#else
+  typedef typename boost::add_const<unqualified_type>::type type;
+#endif
+
+};
+template<class T>
+struct element<0,const T>
+{
+#if BOOST_WORKAROUND(__BORLANDC__,<0x600)
+  typedef const typename T::head_type type;
+#else
+  typedef typename boost::add_const<typename T::head_type>::type type;
+#endif
+};
+
+#else // def BOOST_NO_CV_SPECIALIZATIONS
+
+namespace detail {
+
+template<int N, class T, bool IsConst>
+struct element_impl
+{
+private:
+  typedef typename T::tail_type Next;
+public:
+  typedef typename element_impl<N-1, Next, IsConst>::type type;
+};
+
+template<int N, class T>
+struct element_impl<N, T, true /* IsConst */>
+{
+private:
+  typedef typename T::tail_type Next;
+public:
+  typedef const typename element_impl<N-1, Next, true>::type type;
+};
+
+template<class T>
+struct element_impl<0, T, false /* IsConst */>
+{
+  typedef typename T::head_type type;
+};
+
+template<class T>
+struct element_impl<0, T, true /* IsConst */>
+{
+  typedef const typename T::head_type type;
+};
+
+} // end of namespace detail
+
+
+template<int N, class T>
+struct element: 
+  public detail::element_impl<N, T, ::boost::is_const<T>::value>
+{
+};
+
+#endif
+
+
 // -get function templates -----------------------------------------------
 // Usage: get<N>(aTuple)

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

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

 // get function for non-const cons-lists, returns a reference to the element
@ -189,13 +257,19 @@ template<int N, class HT, class TT>
 inline typename access_traits<
                  typename element<N, cons<HT, TT> >::type
                >::non_const_type
-get(cons<HT, TT>& c BOOST_TUPLE_DUMMY_PARM) { 
-  return detail::get_class<N>::template 
+get(cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+#if BOOST_WORKAROUND(__IBMCPP__,==600 )
+  return detail::get_class<N>::
+#else
+  return detail::get_class<N>::BOOST_NESTED_TEMPLATE
+#endif
         get<
           typename access_traits<
             typename element<N, cons<HT, TT> >::type
-           >::non_const_type>(c); 
-} 
+           >::non_const_type,
+           HT,TT
+         >(c);
+}

 // get function for const cons-lists, returns a const reference to
 // the element. If the element is a reference, returns the reference
@ -204,13 +278,19 @@ template<int N, class HT, class TT>
 inline typename access_traits<
                  typename element<N, cons<HT, TT> >::type
                >::const_type
-get(const cons<HT, TT>& c BOOST_TUPLE_DUMMY_PARM) { 
-  return detail::get_class<N>::template 
+get(const cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+#if BOOST_WORKAROUND(__IBMCPP__,==600)
+  return detail::get_class<N>::
+#else
+  return detail::get_class<N>::BOOST_NESTED_TEMPLATE
+#endif
         get<
           typename access_traits<
             typename element<N, cons<HT, TT> >::type
-         >::const_type>(c);
-} 
+           >::const_type,
+           HT,TT
+         >(c);
+}

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

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

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

  stored_head_type head;
  tail_type tail;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  template<class T1>
-  cons(T1& t1, const null_type&, const null_type&, const null_type&, 
-       const null_type&, const null_type&, const null_type&, 
+  cons(T1& t1, const null_type&, const null_type&, const null_type&,
+       const null_type&, const null_type&, const null_type&,
       const null_type&, const null_type&, const null_type&)
  : head (t1) {}

-  cons(const null_type& t1, 
-       const null_type&, const null_type&, const null_type&, 
-       const null_type&, const null_type&, const null_type&, 
+  cons(const null_type&,
+       const null_type&, const null_type&, const null_type&,
+       const null_type&, const null_type&, const null_type&,
       const null_type&, const null_type&, const null_type&)
  : head () {}

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

 } // namespace detail

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

-#undef BOOST_TUPLE_DUMMY_PARM
-#undef BOOST_TUPLE_SINGLE_DUMMY_PARM

 #endif // BOOST_TUPLE_BASIC_HPP

--- a/include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp
+++ b/include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp
@ -1,32 +1,27 @@
 // - tuple_basic_no_partial_spec.hpp -----------------------------------------

 // Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2001 Doug Gregor (gregod@rpi.edu)
+// Copyright (C) 2001 Douglas Gregor (gregod@rpi.edu)
 // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
 //
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)

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

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

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

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

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

 // forward declaration of tuple
    template<
-      typename T1 = null_type, 
-      typename T2 = null_type, 
-      typename T3 = null_type, 
+      typename T1 = null_type,
+      typename T2 = null_type,
+      typename T3 = null_type,
      typename T4 = null_type,
      typename T5 = null_type,
      typename T6 = null_type,
@ -68,6 +63,10 @@ namespace tuples {
    >
    class tuple;

+// forward declaration of cons
+    template<typename Head, typename Tail = null_type>
+    struct cons;
+
    namespace detail {

      // Takes a pointer and routes all assignments to whatever it points to
@ -92,57 +91,125 @@ namespace tuples {
      struct swallow_assign
      {
        template<typename T>
-        swallow_assign& operator=(const T&)
+        swallow_assign const& operator=(const T&) const
        {
          return *this;
        }
      };

+    template <typename T> struct add_const_reference : add_reference<typename add_const<T>::type> {};
+
+    template <class MyTail>
+    struct init_tail
+    {
+        // Each of vc6 and vc7 seem to require a different formulation
+        // of this return type
+        template <class H, class T>
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+        static typename add_reference<typename add_const<T>::type>::type
+#else
+        static typename add_const_reference<T>::type
+#endif
+        execute( cons<H,T> const& u, long )
+        {
+            return u.get_tail();
+        }
+    };
+
+    template <>
+    struct init_tail<null_type>
+    {
+        template <class H>
+        static null_type execute( cons<H,null_type> const& u, long )
+        {
+            return null_type();
+        }
+
+        template <class U>
+        static null_type execute(U const&, ...)
+        {
+            return null_type();
+        }
+     private:
+        template <class H, class T>
+        void execute( cons<H,T> const&, int);
+    };
+
+    template <class Other>
+    Other const&
+    init_head( Other const& u, ... )
+    {
+        return u;
+    }
+
+    template <class H, class T>
+    typename add_reference<typename add_const<H>::type>::type
+    init_head( cons<H,T> const& u, int )
+    {
+        return u.get_head();
+    }
+
+    inline char**** init_head(null_type const&, int);
+
  } // end of namespace detail

    // cons builds a heterogenous list of types
-   template<typename Head, typename Tail = null_type>
+   template<typename Head, typename Tail>
   struct cons
   {
     typedef cons self_type;
     typedef Head head_type;
     typedef Tail tail_type;

+    private:
+       typedef typename boost::add_reference<head_type>::type head_ref;
+       typedef typename boost::add_reference<tail_type>::type tail_ref;
+       typedef typename detail::add_const_reference<head_type>::type head_cref;
+       typedef typename detail::add_const_reference<tail_type>::type tail_cref;
+    public:
     head_type head;
     tail_type tail;

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

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

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

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

-      explicit cons(const head_type& h = head_type(),
-                    const tail_type& t = tail_type()) :
+      explicit cons(head_cref h = head_type(),
+                    tail_cref t = tail_type()) :
        head(h), tail(t)
      {
      }
 #endif

+      template <class U>
+      cons( const U& u )
+        : head(detail::init_head(u, 0))
+        , tail(detail::init_tail<Tail>::execute(u, 0L))
+       {
+       }

      template<typename Other>
      cons& operator=(const Other& other)
@ -152,13 +219,13 @@ namespace tuples {
        return *this;
      }
    };
-  
+
    namespace detail {

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

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

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

+      typedef typename detail::add_const_reference<T1>::type t1_cref;
+      typedef typename detail::add_const_reference<T2>::type t2_cref;
+      typedef typename detail::add_const_reference<T3>::type t3_cref;
+      typedef typename detail::add_const_reference<T4>::type t4_cref;
+      typedef typename detail::add_const_reference<T5>::type t5_cref;
+      typedef typename detail::add_const_reference<T6>::type t6_cref;
+      typedef typename detail::add_const_reference<T7>::type t7_cref;
+      typedef typename detail::add_const_reference<T8>::type t8_cref;
+      typedef typename detail::add_const_reference<T9>::type t9_cref;
+      typedef typename detail::add_const_reference<T10>::type t10_cref;
    public:
      typedef cons1 inherited;
      typedef tuple self_type;

-      explicit tuple(const T1& t1 = T1(), 
-                     const T2& t2 = T2(),
-                     const T3& t3 = T3(),
-                     const T4& t4 = T4(),
-                     const T5& t5 = T5(),
-                     const T6& t6 = T6(),
-                     const T7& t7 = T7(),
-                     const T8& t8 = T8(),
-                     const T9& t9 = T9(),
-                     const T10& t10 = T10()) :
+      tuple() : cons1(T1(), cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
+        {}
+
+      tuple(
+          t1_cref t1,
+          t2_cref t2,
+          t3_cref t3 = T3(),
+          t4_cref t4 = T4(),
+          t5_cref t5 = T5(),
+          t6_cref t6 = T6(),
+          t7_cref t7 = T7(),
+          t8_cref t8 = T8(),
+          t9_cref t9 = T9(),
+          t10_cref t10 = T10()
+      ) :
        cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10))))))))))
      {
      }

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

 } // namespace tuples
 } // namespace boost
--- a/include/boost/tuple/tuple.hpp
+++ b/include/boost/tuple/tuple.hpp
@ -2,14 +2,9 @@

 // Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)

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

@ -18,6 +13,13 @@
 #ifndef BOOST_TUPLE_HPP
 #define BOOST_TUPLE_HPP

+#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
+// Work around a compiler bug.
+// boost::python::tuple has to be seen by the compiler before the
+// boost::tuple class template.
+namespace boost { namespace python { class tuple; }}
+#endif
+
 #include "boost/config.hpp"
 #include "boost/static_assert.hpp"

--- a/include/boost/tuple/tuple_comparison.hpp
+++ b/include/boost/tuple/tuple_comparison.hpp
@ -3,14 +3,9 @@
 // Copyright (C) 2001 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
 //
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-// 
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 // 
 // For more information, see http://www.boost.org
 // 
--- a/include/boost/tuple/tuple_io.hpp
+++ b/include/boost/tuple/tuple_io.hpp
@ -3,14 +3,9 @@
 // Copyright (C) 2001 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //               2001 Gary Powell (gary.powell@sierra.com)
 //
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 // For more information, see http://www.boost.org 

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

 #include "boost/tuple/tuple.hpp"

+// This is ugly: one should be using twoargument isspace since whitspace can
+// be locale dependent, in theory at least.
+// not all libraries implement have the two-arg version, so we need to 
+// use the one-arg one, which one should get with <cctype> but there seem
+// to be exceptions to this.
+
+#if !defined (BOOST_NO_STD_LOCALE)
+
+#include <locale> // for two-arg isspace
+
+#else 
+
+#include <cctype> // for one-arg (old) isspace 
+#include <ctype.h> // Metrowerks does not find one-arg isspace from cctype
+
+#endif
+
 namespace boost {
 namespace tuples {

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

-  const bool is_delimiter = (!isspace(d) );      
+#if defined (BOOST_NO_STD_LOCALE)
+  const bool is_delimiter = !isspace(d);
+#else
+  const bool is_delimiter = (!std::isspace(d, is.getloc()) );            
+#endif

  char c;
  if (is_delimiter) { 
    is >> c; 
-    if (c!=d) {
+    if (is.good() && c!=d) {
      is.setstate(std::ios::failbit);
    } 
  }
@ -415,12 +431,19 @@ extract_and_check_delimiter(
 {
  const CharType d = format_info::get_manipulator(is, del);

-  const bool is_delimiter = (!isspace(d) );      
+#if defined (BOOST_NO_STD_LOCALE)
+  const bool is_delimiter = !isspace(d);
+#elif defined ( __BORLANDC__ )
+  const bool is_delimiter = !std::use_facet< std::ctype< CharType > >
+    (is.getloc() ).is( std::ctype_base::space, d);
+#else
+  const bool is_delimiter = (!std::isspace(d, is.getloc()) );            
+#endif

  CharType c;
  if (is_delimiter) { 
    is >> c;
-    if (c!=d) { 
+    if (is.good() && c!=d) { 
      is.setstate(std::ios::failbit);
    }
  }
--- a/test/README
+++ b/test/README
@ -1,16 +0,0 @@
-To compile the 
-
-libs/tuple/test/*.cpp 
-
-files, you need to set include paths
-for boost.
-For example, in libs/tuple/test directory you would type (using g++):
-
-g++ -I../../.. tuple_test_bench.cpp
-
-The following is not true anymore:
-
-  If you want to use tuple_io, you need to compile and link src/tuple.cpp:
-  g++ -I../../.. ../src/tuple.cpp io_test.cpp
-
-Thanks to Hartmut Kaiser's suggestion, the tuple.cpp is not needed anymore.
--- a/test/another_tuple_test_bench.cpp
+++ b/test/another_tuple_test_bench.cpp
@ -1,157 +0,0 @@
-//  another_test_bench.cpp  --------------------------------
-
-// This file has various tests to see that things that shouldn't
-// compile, don't compile.
-
-// Defining any of E1 to E5 or E7 to E11 opens some illegal code that 
-// should cause the compliation to fail.
-
-#define BOOST_INCLUDE_MAIN  // for testing, include rather than link
-#include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
-
-#include "boost/tuple/tuple.hpp"
-
-#include <string>
-#include <utility>
-
-using namespace std;
-using namespace boost;
-using namespace boost::tuples;
-
-
-template<class T> void dummy(const T&) {}
-
-class A {}; class B {}; class C {};
-
-// A non-copyable class
-class no_copy {
-  no_copy(const no_copy&) {}
-public:
-  no_copy() {};
-};
-
-no_copy y;
-
-#ifdef E1
-tuple<no_copy> v1;  // should faild
-#endif
-
-
-#ifdef E2
-char cs[10];
-tuple<char[10]> v3;  // should fail, arrays must be stored as references
-#endif
-
-// a class without a public default constructor
-class no_def_constructor {
-  no_def_constructor() {}
-public:
-  no_def_constructor(std::string) {} // can be constructed with a string
-};
-
-void foo1() {
-
-#ifdef E3
-  dummy(tuple<no_def_constructor, no_def_constructor, no_def_constructor>()); 
-  // should fail
-
-#endif
-}
-
-void foo2() {
-// testing default values
-#ifdef E4
-  dummy(tuple<double&>()); // should fail, not defaults for references
-  dummy(tuple<const double&>()); // likewise
-#endif
-
-#ifdef E5
-  double dd = 5;
-  dummy(tuple<double&>(dd+3.14)); // should fail, temporary to non-const reference
-#endif
-}
-
-
-
-// make_tuple ------------------------------------------
-
-
-   void foo3() {
-#ifdef E7
-    std::make_pair("Doesn't","Work"); // fails
-#endif
-    //    make_tuple("Does", "Work"); // this should work
-}
-
-
-
-// - testing element access
-
-void foo4() 
-{
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  double d = 2.7; 
-  A a;
-  tuple<int, double&, const A&> t(1, d, a);
-  const tuple<int, double&, const A> ct = t;
-
-#ifdef E8
-  get<0>(ct) = 5; // can't assign to const
-#endif
-
-#ifdef E9
-  get<4>(t) = A(); // can't assign to const
-#endif
-#ifdef E10
-  dummy(get<5>(ct)); // illegal index
-#endif
-
-#endif
-}
-
-// testing copy and assignment with implicit conversions between elements
-// testing tie
-
-  class AA {};
-  class BB : public AA {};
-  struct CC { CC() {} CC(const BB& b) {} };
-  struct DD { operator CC() const { return CC(); }; };
-
-  void foo5() {
-    tuple<char, BB*, BB, DD> t;
-
-    tuple<char, char> aaa;
-    tuple<int, int> bbb(aaa);
-    //    tuple<int, AA*, CC, CC> a = t;
-    //    a = t;
-  }
-
-
-// testing tie
-// testing assignment from std::pair
-void foo7() {
-
-   tuple<int, int, float> a;
-#ifdef E11
-   a = std::make_pair(1, 2); // should fail, tuple is of length 3, not 2
-#endif
-
-    dummy(a);
-}
-
-
-
-// --------------------------------
-// ----------------------------
-int test_main(int, char *[]) {
-
-  foo1();
-  foo2();
-  foo3();
-  foo4();
-  foo5();
-
-  foo7();
-
-  return 0;
-}
--- a/test/io_test.cpp
+++ b/test/io_test.cpp
@ -1,108 +0,0 @@
-// -- io_test.cpp -----------------------------------------------
-//
-// Testing the I/O facilities of tuples
-
-#define BOOST_INCLUDE_MAIN  // for testing, include rather than link
-#include "boost/test/test_tools.hpp"    // see "Header Implementation Option"
-
-#include "boost/tuple/tuple_io.hpp"
-#include "boost/tuple/tuple_comparison.hpp"
-
-#include <fstream>
-#include <iterator>
-#include <algorithm>
-#include <string>
-
-#if defined BOOST_NO_STRINGSTREAM
-#include <strstream>
-#else
-#include <sstream>
-#endif
-
-#include "boost/config.hpp"
-
-using namespace std;
-using namespace boost;
-
-#if defined BOOST_NO_STRINGSTREAM
-typedef ostrstream useThisOStringStream;
-typedef istrstream useThisIStringStream;
-#else
-typedef ostringstream useThisOStringStream;
-typedef istringstream useThisIStringStream;
-#endif
-
-int test_main(int argc, char * argv[] ) {
-
-   using boost::tuples::set_close;
-   using boost::tuples::set_open;
-   using boost::tuples::set_delimiter;
-   
-  useThisOStringStream os1;
-
-  // Set format [a, b, c] for os1
-  os1 << set_open('[');
-  os1 << set_close(']');
-  os1 << set_delimiter(',');
-  os1 << make_tuple(1, 2, 3);
-  BOOST_TEST (os1.str() == std::string("[1,2,3]") );
-
-  {
-  useThisOStringStream os2;
-  // Set format (a:b:c) for os2; 
-  os2 << set_open('(');
-  os2 << set_close(')');
-  os2 << set_delimiter(':');
-#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  os2 << make_tuple("TUPU", "HUPU", "LUPU", 4.5);
-  BOOST_TEST (os2.str() == std::string("(TUPU:HUPU:LUPU:4.5)") );
-#endif
-  }
-
-  // The format is still [a, b, c] for os1
-  os1 << make_tuple(1, 2, 3);
-  BOOST_TEST (os1.str() == std::string("[1,2,3][1,2,3]") );
-
-  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) << endl;
-
-  tmp.close();
-  
-  // When teading tuples from a stream, manipulators must be set correctly:
-  ifstream tmp3("temp.tmp");
-  tuple<string, string, int> j;
-
-#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  tmp3 >> j; 
-  BOOST_TEST (tmp3.good() ); 
-#endif
-   
-  tmp3 >> set_delimiter(':');
-  tuple<int, int, int> i;
-  tmp3 >> i; 
-  BOOST_TEST (tmp3.good() ); 
-   
-  tmp3.close(); 
-
-
-  // reading tuple<int, int, int> in format (a b c); 
-  useThisIStringStream is("(100 200 300)"); 
-   
-  tuple<int, int, int> ti; 
-  BOOST_TEST(is >> ti);
-  BOOST_TEST(ti == make_tuple(100, 200, 300));
-   
-
-  // Note that strings are problematic:
-  // writing a tuple on a stream and reading it back doesn't work in
-  // general. If this is wanted, some kind of a parseable string class
-  // should be used.
-  
-  return 0;
-}
-
--- a/test/tuple_test_bench.cpp
+++ b/test/tuple_test_bench.cpp
@ -1,500 +0,0 @@
-//  tuple_test_bench.cpp  --------------------------------
-
-#define BOOST_INCLUDE_MAIN  // for testing, include rather than link
-#include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
-
-#include "boost/tuple/tuple.hpp"
-
-#include "boost/tuple/tuple_comparison.hpp"
-
-#include <string>
-#include <utility>
-
-using namespace std;
-using namespace boost;
-
-// ----------------------------------------------------------------------------
-// helpers 
-// ----------------------------------------------------------------------------
-
-class A {}; 
-class B {}; 
-class C {};
-
-// classes with different kinds of conversions
-class AA {};
-class BB : public AA {}; 
-struct CC { CC() {} CC(const BB&) {} };
-struct DD { operator CC() const { return CC(); }; };
-
-// something to prevent warnings for unused variables
-template<class T> void dummy(const T&) {}
-
-// no public default constructor
-class foo {
-public:
-  explicit foo(int v) : val(v) {}
-
-  bool operator==(const foo& other) const  {
-    return val == other.val;
-  }
-
-private:
-  foo() {}
-  int val;
-};
-
-// another class without a public default constructor
-class no_def_constructor {
-  no_def_constructor() {}
-public:
-  no_def_constructor(std::string) {}
-};
-
-// A non-copyable class 
-class no_copy {
-  no_copy(const no_copy&) {}
-public:
-  no_copy() {};
-};
-
-
-// ----------------------------------------------------------------------------
-// Testing different element types --------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-typedef tuple<int> t1;
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-typedef tuple<double&, const double&, const double, double*, const double*> t2;
-typedef tuple<A, int(*)(char, int), C> t3;
-typedef tuple<std::string, std::pair<A, B> > t4;
-typedef tuple<A*, tuple<const A*, const B&, C>, bool, void*> t5;
-typedef tuple<volatile int, const volatile char&, int(&)(float) > t6;
-
-# if !defined(__BORLANDC__) || __BORLAND__ > 0x0551
-typedef tuple<B(A::*)(C&), A&> t7;
-#endif
-
-#endif
-
-// -----------------------------------------------------------------------
-// -tuple construction tests ---------------------------------------------
-// -----------------------------------------------------------------------
-
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-no_copy y;
-tuple<no_copy&> x = tuple<no_copy&>(y); // ok
-#endif
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-char cs[10];
-tuple<char(&)[10]> v2(cs);  // ok
-#endif
-
-void
-construction_test()
-{
-
-  // Note, the get function can be called without the tuples:: qualifier,
-  // as it is lifted to namespace boost with a "using tuples::get" but
-  // MSVC 6.0 just cannot find get without the namespace qualifier
-
-  tuple<int> t1;
-  BOOST_TEST(get<0>(t1) == int());
-
-  tuple<float> t2(5.5f);
-  BOOST_TEST(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f);
-
-  tuple<foo> t3(foo(12));
-  BOOST_TEST(get<0>(t3) == foo(12));
-
-  tuple<double> t4(t2);
-  BOOST_TEST(get<0>(t4) > 5.4 && get<0>(t4) < 5.6);
-
-  tuple<int, float> t5;
-  BOOST_TEST(get<0>(t5) == int());
-  BOOST_TEST(get<1>(t5) == float());
-
-  tuple<int, float> t6(12, 5.5f);
-  BOOST_TEST(get<0>(t6) == 12);
-  BOOST_TEST(get<1>(t6) > 5.4f && get<1>(t6) < 5.6f);
-
-  tuple<int, float> t7(t6);
-  BOOST_TEST(get<0>(t7) == 12);
-  BOOST_TEST(get<1>(t7) > 5.4f && get<1>(t7) < 5.6f);
-
-  tuple<long, double> t8(t6);
-  BOOST_TEST(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>(
-       std::string("Jaba"),   // ok, since the default
-       std::string("Daba"),   // constructor is not used
-       std::string("Doo")
-    )
-  );
-
-// testing default values
-  dummy(tuple<int, double>());
-  dummy(tuple<int, double>(1));
-  dummy(tuple<int, double>(1,3.14));
-
-
-  //  dummy(tuple<double&>()); // should fail, not defaults for references
-  //  dummy(tuple<const double&>()); // likewise
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  double dd = 5;
-  dummy(tuple<double&>(dd)); // ok
-
-  dummy(tuple<const double&>(dd+3.14)); // ok, but dangerous
-#endif
-
-  //  dummy(tuple<double&>(dd+3.14)); // should fail,
-  //                                  // temporary to non-const reference
-}
-
-
-// ----------------------------------------------------------------------------
-// - testing element access ---------------------------------------------------
-// ----------------------------------------------------------------------------
-
-void element_access_test()
-{
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  double d = 2.7;
-  A a;
-  tuple<int, double&, const A&, int> t(1, d, a, 2);
-  const tuple<int, double&, const A, int> ct = t;
-
-  int i  = get<0>(t);
-  int i2 = get<3>(t);
-
-  BOOST_TEST(i == 1 && i2 == 2);
-
-  int j  = get<0>(ct);
-  BOOST_TEST(j == 1);
-   
-  get<0>(t) = 5;
-  BOOST_TEST(t.head == 5);
-   
-  //  get<0>(ct) = 5; // can't assign to const
-
-  double e = get<1>(t);
-  BOOST_TEST(e > 2.69 && e < 2.71);
-     
-  get<1>(t) = 3.14+i;
-  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
-
-  //  get<4>(t) = A(); // can't assign to const
-  //  dummy(get<5>(ct)); // illegal index
-
-  ++get<0>(t);
-  BOOST_TEST(get<0>(t) == 6);
-
-  dummy(i); dummy(i2); dummy(j); dummy(e); // avoid warns for unused variables
-#else
-  double d = 2.7; 
-  A a;
-  tuple<int, double, const A, int> t(1, d, a, 2);
-
-  int i  = get<0>(t);
-  int i2 = get<3>(t);
-
-  BOOST_TEST(i == 1 && i2 == 2);
-   
-  get<0>(t) = 5;
-  BOOST_TEST(t.head == 5);
-   
-  //  get<0>(ct) = 5; // can't assign to const
-
-  double e = get<1>(t);
-  BOOST_TEST(e > 2.69 && e < 2.71);
-     
-  get<1>(t) = 3.14+i;
-  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
-
-  //  get<4>(t) = A(); // can't assign to const
-  //  dummy(get<5>(ct)); // illegal index
-
-  ++get<0>(t);
-  BOOST_TEST(get<0>(t) == 6);
-
-  dummy(i); dummy(i2); dummy(e); // avoid warns for unused variables
-#endif
-}
-
-
-// ----------------------------------------------------------------------------
-// - copying tuples -----------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-
-void
-copy_test()
-{
-  tuple<int, char> t1(4, 'a');
-  tuple<int, char> t2(5, 'b');
-  t2 = t1;
-  BOOST_TEST(get<0>(t1) == get<0>(t2));
-  BOOST_TEST(get<1>(t1) == get<1>(t2));
-
-  tuple<long, std::string> t3(2, "a");
-  t3 = t1;
-  BOOST_TEST((double)get<0>(t1) == get<0>(t3));
-  BOOST_TEST(get<1>(t1) == get<1>(t3)[0]);
-
-// testing copy and assignment with implicit conversions between elements
-// testing tie
-
-  tuple<char, BB*, BB, DD> t;
-  tuple<int, AA*, CC, CC> a(t);
-  a = t;
-
-  int i; char c; double d;
-  tie(i, c, d) = make_tuple(1, 'a', 5.5);
-  
-  BOOST_TEST(i==1);
-  BOOST_TEST(c=='a');
-  BOOST_TEST(d>5.4 && d<5.6);
-}
-
-void
-mutate_test()
-{
-  tuple<int, float, bool, foo> t1(5, 12.2f, true, foo(4));
-  get<0>(t1) = 6;
-  get<1>(t1) = 2.2f;
-  get<2>(t1) = false;
-  get<3>(t1) = foo(5);
-
-  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));
-}
-
-// ----------------------------------------------------------------------------
-// make_tuple tests -----------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-void
-make_tuple_test()
-{
-  tuple<int, char> t1 = make_tuple(5, 'a');
-  BOOST_TEST(get<0>(t1) == 5);
-  BOOST_TEST(get<1>(t1) == 'a');
-
-  tuple<int, std::string> t2;
-  t2 = make_tuple((short int)2, std::string("Hi"));
-  BOOST_TEST(get<0>(t2) == 2);
-  BOOST_TEST(get<1>(t2) == "Hi");
-
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-    A a; B b;
-    const A ca = a;
-    make_tuple(cref(a), b);
-    make_tuple(ref(a), b);
-    make_tuple(ref(a), cref(b));
-
-    make_tuple(ref(ca));
-#endif
-     
-// the result of make_tuple is assignable:
-   BOOST_TEST(make_tuple(2, 4, 6) == 
-             (make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-    make_tuple("Donald", "Daisy"); // should work;
-#endif
-    //    std::make_pair("Doesn't","Work"); // fails
-
-// You can store a reference to a function in a tuple
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-    tuple<void(&)()> adf(make_tuple_test);
-
-    dummy(adf); // avoid warning for unused variable
-#endif
- 
-// But make_tuple doesn't work 
-// with function references, since it creates a const qualified function type
-
-//   make_tuple(make_tuple_test);
-  
-// With function pointers, make_tuple works just fine
-
-#if !defined(__BORLANDC__) || __BORLAND__ > 0x0551
-   make_tuple(&make_tuple_test);
-#endif
-      
-// NOTE:
-//
-// wrapping it the function reference with ref helps on gcc 2.95.2.
-// on edg 2.43. it results in a catastrophic error?
-
-// make_tuple(ref(foo3));
-
-// It seems that edg can't use implicitly the ref's conversion operator, e.g.:
-// typedef void (&func_t) (void);
-// func_t fref = static_cast<func_t>(ref(make_tuple_test)); // works fine 
-// func_t fref = ref(make_tuple_test);                        // error
-
-// This is probably not a very common situation, so currently
-// I don't know how which compiler is right (JJ)
-}
-
-void
-tie_test()
-{
-  int a;
-  char b;
-  foo c(5);
-
-  tie(a, b, c) = make_tuple(2, 'a', foo(3));
-  BOOST_TEST(a == 2);
-  BOOST_TEST(b == 'a');
-  BOOST_TEST(c == foo(3));
-
-  tie(a, tuples::ignore, c) = make_tuple((short int)5, false, foo(5));
-  BOOST_TEST(a == 5);
-  BOOST_TEST(b == 'a');
-  BOOST_TEST(c == foo(5));
-
-// testing assignment from std::pair
-   int i, j; 
-   tie (i, j) = std::make_pair(1, 2);
-   BOOST_TEST(i == 1 && j == 2);
-
-   tuple<int, int, float> ta;
-#ifdef E11
-   ta = std::make_pair(1, 2); // should fail, tuple is of length 3, not 2
-#endif
-
-   dummy(ta);
-}
-
-
-// ----------------------------------------------------------------------------
-// - testing tuple equality   -------------------------------------------------
-// ----------------------------------------------------------------------------
-
-void
-equality_test()
-{
-  tuple<int, char> t1(5, 'a');
-  tuple<int, char> t2(5, 'a');
-  BOOST_TEST(t1 == t2);
-
-  tuple<int, char> t3(5, 'b');
-  tuple<int, char> t4(2, 'a');
-  BOOST_TEST(t1 != t3);
-  BOOST_TEST(t1 != t4);
-  BOOST_TEST(!(t1 != t2));
-}
-
-
-// ----------------------------------------------------------------------------
-// - testing tuple comparisons  -----------------------------------------------
-// ----------------------------------------------------------------------------
-
-void
-ordering_test()
-{
-  tuple<int, float> t1(4, 3.3f);
-  tuple<short, float> t2(5, 3.3f);
-  tuple<long, double> t3(5, 4.4);
-  BOOST_TEST(t1 < t2);
-  BOOST_TEST(t1 <= t2);
-  BOOST_TEST(t2 > t1);
-  BOOST_TEST(t2 >= t1);
-  BOOST_TEST(t2 < t3);
-  BOOST_TEST(t2 <= t3);
-  BOOST_TEST(t3 > t2);
-  BOOST_TEST(t3 >= t2);
-
-}
-
-
-// ----------------------------------------------------------------------------
-// - testing cons lists -------------------------------------------------------
-// ----------------------------------------------------------------------------
-void cons_test()
-{
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  using tuples::cons;
-  using tuples::null_type;
-
-  cons<volatile float, null_type> a(1, null_type());
-  cons<const int, cons<volatile float, null_type> > b(2,a);
-  int i = 3;
-  cons<int&, cons<const int, cons<volatile float, null_type> > > c(i, b);
-  BOOST_TEST(make_tuple(3,2,1)==c);
-
-  cons<char, cons<int, cons<float, null_type> > > x;
-  dummy(x);
-#endif
-}
-
-// ----------------------------------------------------------------------------
-// - testing const tuples -----------------------------------------------------
-// ----------------------------------------------------------------------------
-void const_tuple_test()
-{
-  const tuple<int, float> t1(5, 3.3f);
-  BOOST_TEST(get<0>(t1) == 5);
-  BOOST_TEST(get<1>(t1) == 3.3f);
-}
-
-// ----------------------------------------------------------------------------
-// - testing length -----------------------------------------------------------
-// ----------------------------------------------------------------------------
-void tuple_length_test()
-{
-  typedef tuple<int, float, double> t1;
-  using tuples::cons;
-  typedef cons<int, cons< float, cons <double, tuples::null_type> > > t1_cons;
-  typedef tuple<> t2;
-  typedef tuples::null_type t3;  
-
-  BOOST_STATIC_ASSERT(tuples::length<t1>::value == 3);
-  BOOST_STATIC_ASSERT(tuples::length<t1_cons>::value == 3);
-  BOOST_STATIC_ASSERT(tuples::length<t2>::value == 0);
-  BOOST_STATIC_ASSERT(tuples::length<t3>::value == 0);
-
-}
-
-
-
-
-// ----------------------------------------------------------------------------
-// - main ---------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-int test_main(int, char *[]) {
-
-  construction_test();
-  element_access_test();
-  copy_test();
-  mutate_test();
-  make_tuple_test();
-  tie_test();
-  equality_test();
-  ordering_test();
-  cons_test();
-  const_tuple_test();
-  tuple_length_test();
-  return 0;
-}
-
-
-
-
-
-
-
Author	SHA1	Message	Date
nobody	8645e388d9	This commit was manufactured by cvs2svn to create branch 'thread_rewrite'. [SVN r30953]	2005-09-13 14:20:32 +00:00
Jaakko Järvi	2d13a60d05	applied patch by Rupert Kittinger, avoids potentially undefined behavior [SVN r30690]	2005-08-26 16:03:05 +00:00
John Maddock	9c6ef41dfe	Large patch from Ulrich Eckhardt to fix support for EVC++ 4. [SVN r30670]	2005-08-25 16:27:28 +00:00
Douglas Gregor	5686969287	Merged from 1.33.0 release [SVN r30540]	2005-08-12 13:02:37 +00:00
Stefan Slapeta	a17ce206f2	replaced BOOST_TEST [SVN r27057]	2005-02-03 13:55:45 +00:00
Joaquín M. López Muñoz	34690282fe	fixes in element<> for BCB compilers, with help from Tobias Schwinger [SVN r25763]	2004-10-18 06:03:18 +00:00
Aleksey Gurtovoy	bc3d37ec2b	c++boost.gif -> boost.png replacement [SVN r25573]	2004-10-05 15:45:52 +00:00
Douglas Gregor	eea1937afc	Converted to Boost Software License, Version 1.0 [SVN r24096]	2004-07-27 03:43:34 +00:00
Douglas Gregor	8820994ffd	Doug Gregor -> Douglas Gregor [SVN r24016]	2004-07-25 02:29:29 +00:00
Toon Knapen	045d761ab5	suppressed scoping the call get_class to the detail namespace [SVN r23113]	2004-06-17 13:51:33 +00:00
Toon Knapen	63c93b59b4	port to vacpp: added default template arguments explicitly (Joaquin M Lopez) removed member template keyword (Toon Knapen) [SVN r23109]	2004-06-17 07:01:13 +00:00
Dave Abrahams	78572fca7b	Bug fix for vc6 [SVN r20866]	2003-11-19 22:01:52 +00:00
Joel de Guzman	ad29f96e5b	updated swallow_assign constness bug [SVN r20520]	2003-10-28 09:42:43 +00:00
Joel de Guzman	9734556efe	made "ingnore" a const object to avoid linker errors [SVN r20449]	2003-10-21 23:25:17 +00:00
Jaakko Järvi	c8e03a518b	added praise for Dave for improving tuple support on non-partial template specialization compilers [SVN r19965]	2003-09-08 15:10:04 +00:00
Dave Abrahams	e4b869219b	More complete functionality for compilers without partial specialization. [SVN r19925]	2003-09-05 16:52:55 +00:00
Dave Abrahams	eef0e01c8d	Adjust for changed test library name [SVN r19924]	2003-09-05 16:18:53 +00:00
Jaakko Järvi	41d649b08c	cleaning up after previous commit [SVN r19688]	2003-08-18 19:35:29 +00:00
Jaakko Järvi	122bf636f5	getting rid of some library specific macros and using BOOST_NO_EXPLICIT_- FUNCTION_TEMPLATE_ARGUMENTS related helper macros from the config library [SVN r19687]	2003-08-18 19:33:47 +00:00
Jaakko Järvi	359eaeecbf	added tests to ensure correct constness behaviour [SVN r18871]	2003-06-26 15:19:01 +00:00
Jaakko Järvi	28e34eb757	fixed a typo [SVN r18386]	2003-05-12 14:51:42 +00:00
Dave Abrahams	5ea6623d49	restore from disk crash [SVN r18353]	2003-05-08 02:19:10 +00:00
Jaakko Järvi	d349450992	fixed a few links [SVN r18344]	2003-05-07 16:01:33 +00:00
Jaakko Järvi	8b4daa1385	patch of a patch [SVN r17706]	2003-03-03 16:45:55 +00:00
Jaakko Järvi	1972959fda	element<T>::type takes constness into consideration [SVN r17666]	2003-02-26 23:10:55 +00:00
Jaakko Järvi	496cc84960	a patch for borland [SVN r17660]	2003-02-26 16:04:56 +00:00
Jaakko Järvi	c1a28e5d81	typofix [SVN r17557]	2003-02-20 15:30:48 +00:00
Björn Karlsson	4d4fe0010f	Added copyright statement [SVN r17193]	2003-02-04 11:54:01 +00:00
Dave Abrahams	8992af95d1	Link bug workaround for MSVC and old Dec CXX [SVN r16342]	2002-11-20 13:17:52 +00:00
Jaakko Järvi	ae40fce7c9	added namespace qualifiers to make MIPS PRO happy [SVN r16033]	2002-10-31 18:14:29 +00:00
Jaakko Järvi	607b65a946	fixing a borland warning [SVN r15810]	2002-10-08 19:24:36 +00:00
Jaakko Järvi	2c213c8295	fix one borland warning [SVN r15808]	2002-10-08 18:43:52 +00:00
Jaakko Järvi	5b8506c39b	typo fixes [SVN r15652]	2002-10-02 16:51:43 +00:00
Jaakko Järvi	22f56bbe58	fixed Bemans name in a comment [SVN r15594]	2002-10-01 03:26:10 +00:00
Ralf W. Grosse-Kunstleve	fb8fa3c7b6	work-around for MIPSpro bug [SVN r15574]	2002-09-30 19:45:22 +00:00
Dave Abrahams	cc5a2ae388	Fixes which make it possible to declare with reference elements [SVN r15532]	2002-09-28 07:25:27 +00:00
Jaakko Järvi	4cd544f4c1	applied patch Markus Schöpflin, ::template replaced with ::BOOST_NESTED_TEMPLATE [SVN r15466]	2002-09-20 15:55:10 +00:00
Jaakko Järvi	74a2ab1242	changed jamfile includes from <include> to <sysinclude> [SVN r15305]	2002-09-13 16:26:12 +00:00
Jaakko Järvi	7896766f8f	a fix of a fix [SVN r15278]	2002-09-12 20:59:05 +00:00
Jaakko Järvi	0a33edd21d	workaround for isspace and metrowerks [SVN r15277]	2002-09-12 20:50:10 +00:00
Jaakko Järvi	53c1bb2c20	removed an extraneous include [SVN r14993]	2002-08-20 15:54:11 +00:00
Jaakko Järvi	ea8d71487d	workaround for boost test library problem [SVN r14992]	2002-08-20 15:51:36 +00:00
Jaakko Järvi	6a92d10f25	added a redirection index.html file [SVN r14898]	2002-08-15 18:26:17 +00:00
Jaakko Järvi	3570bdb6b6	fixed some warningns about unused variables, added Jamfile [SVN r14854]	2002-08-14 20:55:52 +00:00