Created a branch from trunk

[SVN r38959]
Update to V2
2007-08-26 05:34:35 +00:00 · 2007-08-08 19:42:04 +00:00 · 2007-02-06 00:23:26 +00:00 · 2007-01-07 23:50:56 +00:00 · 2006-11-07 19:11:57 +00:00 · 2006-01-22 19:29:32 +00:00
16 changed files with 1758 additions and 1108 deletions
--- a/doc/design_decisions_rationale.html
+++ b/doc/design_decisions_rationale.html
@ -4,7 +4,7 @@
 <body bgcolor="#FFFFFF" text="#000000">
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
     ALT="C++ Boost" width="277" height="86">
 <h1>Tuple Library : design decisions rationale</h1>
@ -12,42 +12,63 @@
 <h2>About namespaces</h2>
 <p>
-There was a discussion about whether tuples should be in a separate namespace or directly at the <code>boost</code> namespace.
+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
-sub-namespace, while utility like libraries directly in the <code>boost</code> namespace.
+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. 
-As a result of the discussion, tuple definitions are now directly under the <code>boost</code> namespace.
+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>
-Note! The following discussion is not relevant for the Tuple library, as the 'no
+The subnamespace name <i>tuples</i> raised some discussion.
-sub-namespace' decision was taken, but it may be useful for other library writers.
+The rationale for not using the most natural name 'tuple' is to avoid having an identical name with the tuple template. 
-</p>
+Namespace names are, however, not generally in plural form in boost libraries. 
-<p>
+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'.
 In the original tuple library submission, all names were under the namespace <code>tuples</code>. This brought up the issue of naming
 sub-namespaces.
 The rationale for not using the most natural name 'tuple' was to avoid having an identical name with the tuple template. Namespace names are, however, not generally in plural form in boost libraries. Further, no real trouble was reported for using the same name for a namespace and a class. 
 But we found some trouble after all.
-One solution proposed to the dilemma of introducing a sub-namespace or not was as follows: use a
+Both gcc and edg compilers reject using declarations where the namespace and class names are identical:
 sub-namespace but lift the most common names to the <code>boost</code> namespace with using declarations. 
 Both gcc and edg compilers rejected such using declarations if the namespace and class names were identical:
 <code><pre>namespace boost {
  namespace tuple {
-    class cons;
+    ... tie(...);
    class tuple; 
 &nbsp;     ...
  }
-  using tuple::cons; // ok
+  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: 
 Note, however, that a corresponding using declaration in the global namespace seemed to be ok: 
 <code><pre>
 using boost::tuple::tuple; // ok;
--- a/doc/tuple_advanced_interface.html
+++ b/doc/tuple_advanced_interface.html
@ -4,7 +4,7 @@
    <title>Tuple library advanced features</title>
 <body bgcolor="#FFFFFF" text="#000000">
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
     ALT="C++ Boost" width="277" height="86">
  </head>
@ -12,17 +12,20 @@
  <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>tuple_element&lt;N, T&gt;::type</pre></code>
+<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>.
+gives the type of the <code>N</code>th element in the tuple type <code>T</code>. If <code>T</code> is const, the resulting type is const qualified as well. 
 Note that the constness of <code>T</code> does not affect reference type
 elements.
 </p>
-<code><pre>tuple_length&lt;T&gt;::value</pre></code>
+<code><pre>length&lt;T&gt;::value</pre></code>
 gives the length of the tuple type <code>T</code>.
 </p>
@ -77,9 +80,12 @@ inline void set_to_zero(cons&lt;H, T&gt;&amp; x) { x.get_head() = 0; set_to_zero
 <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 tuple_access_traits&lt;head_type&gt;::parameter_type h,
+<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).
@ -88,15 +94,16 @@ The traits template for the head parameter selects correct parameter types for d
 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>tuple_access_traits</code></h4>
+<h4><code>access_traits</code></h4>
 <p>
-The template <code>tuple_access_traits</code> defines three type functions. Let <code>T</code> be a type of an element in a tuple:
+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>tuple_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;::non_const_type</code> maps <code>T</code> to the return type of the non-const access functions (nonmeber and member <code>get</code> functions, and the <code>get_head</code> function).</li>
-<li><code>tuple_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;::const_type</code> maps <code>T</code> to the return type of the const access functions.</li>
-<li><code>tuple_access_traits&lt;T&gt;::parameter_type</code> maps <code>T</code> to the parameter type of the tuple constructor.</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>
@ -116,7 +123,8 @@ The type function call <code>make_tuple_traits&lt;T&gt;::type</code> implements
 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>Note, that the <code>reference_wrapper</code> template and the <code>ref</code> and <code>cref</code> functions are defined in a separate hpp-file <code>reference_wrappers.hpp</code>, which can be included without including the rest of the tuple library.
+<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>
--- a/doc/tuple_users_guide.html
+++ b/doc/tuple_users_guide.html
@ -4,7 +4,7 @@
 </head>
 <body bgcolor="#FFFFFF" text="#000000">
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
     ALT="C++ Boost" width="277" height="86">
 <h1>The Boost Tuple Library</h1>
@ -63,11 +63,10 @@ To compensate for this &quot;deficiency&quot;, the Boost Tuple Library implement
 <p>To use tuple input and output operators,
 <pre><code>#include &quot;boost/tuple/tuple_io.hpp&quot;</code></pre>
 and add the <code>libs/tuple/src/tuple.hpp</code> file to your project.
 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</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>
@ -75,13 +74,14 @@ Both <code>tuple_io.hpp</code> and <code>tuple_comparison.hpp</code> include <co
 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, except for a type that cannot be copied, e.g.:
+The data element can be any C++ type.
-
+Note that <code>void</code> and plain function types are valid 
-<ul>
+C++ types, but objects of such types cannot exist. 
-<li>classes that do not have a public copy constructor</li>
+Hence, if a tuple type contains such types as elements, the tuple type
-<li>arrays</li>
+can exist, but not an object of that type.
-</ul>
+There are natural limitations for element types that cannot
-However, a reference to a non-copyable type is a valid element type.
+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):
@ -93,26 +93,11 @@ 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>
 <p>
 The following code shows some invalid tuple instantiations:
 <pre><code>class Y { 
  Y(const Y&amp;); 
 public:
  Y();
 };
 tuple&lt;Y&gt;        // not allowed, objects of type Y cannot be copied
 tuple&lt;char[10]&gt; // not allowed: arrays cannot be copied
 </code></pre>
 Note however that <code>tuple&lt;Y&amp;&gt;</code> and <code>tuple&lt;char(&)[10]&gt;</code> are valid instantiations.
 <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 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) 
@ -148,6 +133,31 @@ 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>
@ -192,7 +202,7 @@ Array arguments to <code>make_tuple</code> functions are deduced to reference to
 <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> 
+This creates an object of type <code>tuple&lt;const char (&amp;)[7], const char (&amp;)[6]&gt;</code> 
 (note that the type of a string literal is an array of const characters, not <code>const char*</code>). 
 However, to get <code>make_tuple</code> to create a tuple with an element of a
 non-const array type one must use the <code>ref</code> wrapper.
@ -243,6 +253,10 @@ 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>
@ -250,10 +264,10 @@ A tuple can be copy constructed from another tuple, provided that the element ty
 Analogously, a tuple can be assigned to another tuple, provided that the element types are element-wise assignable.
 For example:
-<pre><code>class A;
+<pre><code>class A {};
 class B : public A {};
-struct C { C(); C(const B&amp;); }
+struct C { C(); C(const B&amp;); };
-struct D { operator C() const; }
+struct D { operator C() const; };
 tuple&lt;char, B*, B, D&gt; t;
  ...
 tuple&lt;int, A*, C, C&gt; a(t); // ok 
@ -334,10 +348,10 @@ 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:
+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(ignore, c) = std::make_pair(1, 'a');
+tie(tuples::ignore, c) = std::make_pair(1, 'a');
 </code></pre>
 <h2><a name = "streaming">Streaming</a></h2>
@ -373,8 +387,9 @@ last element.</li>
 elements.</li>
 </ul>
 Note, that these manipulators are defined in the <code>tuples</code> subnamespace. 
 For example:
-<code><pre>cout &lt;&lt; set_open('[') &lt;&lt; set_close(']') &lt;&lt; set_delimiter(',') &lt;&lt; a; 
+<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>
@ -388,7 +403,7 @@ The code:
 tuple&lt;int, int&gt; j;
 cin &gt;&gt; i;
-cin &gt;&gt; set_open('[') &gt;&gt; set_close(']') &gt;&gt; set_delimiter(':');
+cin &gt;&gt; tuples::set_open('[') &gt;&gt; tuples::set_close(']') &gt;&gt; tules::set_delimiter(':');
 cin &gt;&gt; j;
 </code></pre>
@ -402,8 +417,9 @@ parseable.
 <h2><a name = "performance">Performance</a></h2>
-Tuples are efficient. All functions are small inlined one-liners and a decent compiler will eliminate any extra cost. 
+All tuple access and construction functions are small inlined one-liners. 
-Particularly, there is no performance difference between this code:
+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;
@ -425,6 +441,8 @@ and this code:
 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. 
@ -442,8 +460,8 @@ f1(i,d);         // #1
 tie(i,d) = f2(); // #2
 </code></pre>
 See 
-[<a href=#publ_1>1</a>,
+[<a href="#publ_1">1</a>,
-<a href=#publ_2>2</a>]
+<a href="#publ_2">2</a>]
 for more in-depth discussions about efficiency.
 <h4>Effect on Compile Time</h4>
@ -454,8 +472,8 @@ Depending on the compiler and the tuple length, it may be more than 10 times slo
 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_1">1</a>,
-<a href=#publ_2>2</a>]
+<a href="#publ_2">2</a>]
 for details.
 </p>
@ -474,21 +492,20 @@ Below is a list of compilers and known problems with each compiler:
 </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, Jens Maurer for their help and suggestions. 
+Gary Powell has been an indispensable helping hand. In particular, stream manipulators for tuples were his idea. Doug Gregor came up with a working version for MSVC, David Abrahams found a way to get rid of most of the restrictions for compilers not supporting partial specialization. Thanks to Jeremy Siek, William Kempf and Jens Maurer for their help and suggestions. 
-The comments by Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes and David Abrahams helped to improve the
+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>).
+J&auml;rvi J.: <i>Tuples and multiple return values in C++</i>, TUCS Technical Report No 249, 1999<!-- (<a href="http://www.tucs.fi/Publications">http://www.tucs.fi/Publications</a>)-->.
 </p>
 <p>
 <a name="publ_2"></a>[2]
-J&auml;rvi J.: <i>ML-Style Tuple Assignment in Standard C++ - Extending the Multiple Return Value Formalism</i>, TUCS Technical Report No 267, 1999 (<a href="http://www.tucs.fi/publications">http://www.tucs.fi/publications</a>).
+J&auml;rvi J.: <i>ML-Style Tuple Assignment in Standard C++ - Extending the Multiple Return Value Formalism</i>, TUCS Technical Report No 267, 1999<!-- (<a href="http://www.tucs.fi/Publications">http://www.tucs.fi/Publications</a>)-->.
 </p>
 <p>
@ -497,7 +514,7 @@ J&auml;rvi J.: <i>ML-Style Tuple Assignment in Standard C++ - Extending the Mult
 <hr>
-<p>Last modified 2001-08-10</p>
+<p>Last modified 2003-09-07</p>
 <p>&copy; Copyright <a href="../../../people/jaakko_jarvi.htm"> Jaakko J&auml;rvi</a> 2001. 
--- a/include/boost/tuple/detail/tuple_basic.hpp
+++ b/include/boost/tuple/detail/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,37 +1,33 @@
 // - 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
+// Distributed under the Boost Software License, Version 1.0. (See
-// provided this copyright notice appears in all copies. 
+// accompanying file LICENSE_1_0.txt or copy at
-// Permission to modify the code and to distribute modified code is granted
+// http://www.boost.org/LICENSE_1_0.txt)
 // provided this copyright notice appears in all copies, and a notice 
 // that the code was modified is included with the copyright notice.
 //
 // This software is provided "as is" without express or implied warranty, 
 // and with no claim as to its suitability for any purpose.
-// For more information, see http://www.boost.org or http://lambda.cs.utu.fi 
+// 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
 #include "boost/type_traits.hpp"
 #include <utility>
 #if defined BOOST_MSVC
 #pragma warning(disable:4518) // storage-class or type specifier(s) unexpected here; ignored
@ -40,19 +36,39 @@
 #endif
 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 T4 = null_type,
      typename T5 = null_type,
      typename T6 = null_type,
      typename T7 = null_type,
      typename T8 = null_type,
      typename T9 = null_type,
      typename T10 = null_type
    >
    class tuple;
 // forward declaration of cons
    template<typename Head, typename Tail = null_type>
    struct cons;
    namespace detail {
-    namespace tuples {
+
      // Takes a pointer and routes all assignments to whatever it points to
      template<typename T>
      struct assign_to_pointee
@ -75,51 +91,125 @@ namespace boost {
      struct swallow_assign
      {
        template<typename T>
-        swallow_assign& operator=(const T&)
+        swallow_assign const& operator=(const T&) const
        {
          return *this;
        }
      };
-  } // end of namespace tuples
+    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
+   struct cons
-    {
+   {
-      typedef cons self_type;
+     typedef cons self_type;
-      typedef Head head_type;
+     typedef Head head_type;
-      typedef Tail tail_type;
+     typedef Tail tail_type;
-      head_type head;
+    private:
-      tail_type tail;
+       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; }
+     head_ref get_head() { return head; }
-      typename boost::add_reference<tail_type>::type get_tail() { return tail; }  
+     tail_ref get_tail() { return tail; }
-      typename boost::add_reference<const head_type>::type get_head() const { return head; }
+     head_cref get_head() const { return head; }
-      typename boost::add_reference<const tail_type>::type get_tail() const { return tail; }
+     tail_cref get_tail() const { return tail; }
-  
+
-      template<typename Other>
+     cons() : head(), tail() {}
      explicit cons(const Other& other) : head(other.head), tail(other.tail)
      {
      }
 #if defined BOOST_MSVC
-      explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
+      template<typename Tail>
-        const tail_type& t = tail_type()) :
+      cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
-          head(h), tail(t)
+                    const Tail& t) : head(h), tail(t.head, t.tail)
      {
      }
      cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
                    const null_type& t) : head(h), tail(t)
      {
      }
 #else
-      explicit cons(const head_type& h = head_type(),
+      template<typename T>
-                    const tail_type& t = tail_type()) :
+      explicit cons(head_cref h, const T& t) :
        head(h), tail(t.head, t.tail)
      {
      }
      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)
@ -129,13 +219,13 @@ namespace boost {
        return *this;
      }
    };
-  
+
    namespace detail {
-    namespace tuples {
+
      // 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>
@ -155,29 +245,29 @@ namespace boost {
      // Map the N elements of a tuple into a cons list
      template<
-        typename T1, 
+        typename T1,
-        typename T2 = null_type, 
+        typename T2 = null_type,
-        typename T3 = null_type, 
+        typename T3 = null_type,
-        typename T4 = null_type, 
+        typename T4 = null_type,
-        typename T5 = null_type, 
+        typename T5 = null_type,
-        typename T6 = null_type, 
+        typename T6 = null_type,
-        typename T7 = null_type, 
+        typename T7 = null_type,
-        typename T8 = null_type, 
+        typename T8 = null_type,
-        typename T9 = null_type, 
+        typename T9 = null_type,
        typename T10 = null_type
      >
      struct map_tuple_to_cons
      {
-        typedef typename detail::tuples::build_cons<T10, null_type  >::RET cons10;
+        typedef typename detail::build_cons<T10, null_type  >::RET cons10;
-        typedef typename detail::tuples::build_cons<T9, cons10>::RET cons9;
+        typedef typename detail::build_cons<T9, cons10>::RET cons9;
-        typedef typename detail::tuples::build_cons<T8, cons9>::RET cons8;
+        typedef typename detail::build_cons<T8, cons9>::RET cons8;
-        typedef typename detail::tuples::build_cons<T7, cons8>::RET cons7;
+        typedef typename detail::build_cons<T7, cons8>::RET cons7;
-        typedef typename detail::tuples::build_cons<T6, cons7>::RET cons6;
+        typedef typename detail::build_cons<T6, cons7>::RET cons6;
-        typedef typename detail::tuples::build_cons<T5, cons6>::RET cons5;
+        typedef typename detail::build_cons<T5, cons6>::RET cons5;
-        typedef typename detail::tuples::build_cons<T4, cons5>::RET cons4;
+        typedef typename detail::build_cons<T4, cons5>::RET cons4;
-        typedef typename detail::tuples::build_cons<T3, cons4>::RET cons3;
+        typedef typename detail::build_cons<T3, cons4>::RET cons3;
-        typedef typename detail::tuples::build_cons<T2, cons3>::RET cons2;
+        typedef typename detail::build_cons<T2, cons3>::RET cons2;
-        typedef typename detail::tuples::build_cons<T1, cons2>::RET cons1;
+        typedef typename detail::build_cons<T1, cons2>::RET cons1;
      };
      // Workaround the lack of partial specialization in some compilers
@ -205,15 +295,16 @@ namespace boost {
          typedef typename Tuple::head_type RET;
        };
      };
-    } // detail
+
-    } // tuples
+    } // namespace detail
    // Return the Nth type of the given Tuple
    template<int N, typename Tuple>
-    struct tuple_element
+    struct element
    {
    private:
-      typedef detail::tuples::_element_type<N> nth_type;
+      typedef detail::_element_type<N> nth_type;
    public:
      typedef typename nth_type::template inner<Tuple>::RET RET;
@ -221,13 +312,65 @@ namespace boost {
    };
    namespace detail {
-    namespace tuples {
+
 #if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
      // special workaround for vc7:
      template <bool x>
      struct reference_adder
      {
         template <class T>
         struct rebind
         {
            typedef T& type;
         };
      };
      template <>
      struct reference_adder<true>
      {
         template <class T>
         struct rebind
         {
            typedef T type;
         };
      };
      // Return a reference to the Nth type of the given Tuple
      template<int N, typename Tuple>
-      struct tuple_element_ref
+      struct element_ref
      {
      private:
-        typedef typename tuple_element<N, Tuple>::RET elt_type;
+         typedef typename element<N, Tuple>::RET elt_type;
         enum { is_ref = is_reference<elt_type>::value };
      public:
         typedef reference_adder<is_ref>::rebind<elt_type>::type RET;
         typedef RET type;
      };
      // Return a const reference to the Nth type of the given Tuple
      template<int N, typename Tuple>
      struct element_const_ref
      {
      private:
         typedef typename element<N, Tuple>::RET elt_type;
         enum { is_ref = is_reference<elt_type>::value };
      public:
         typedef reference_adder<is_ref>::rebind<const elt_type>::type RET;
         typedef RET type;
      };
 #else // vc7
      // Return a reference to the Nth type of the given Tuple
      template<int N, typename Tuple>
      struct element_ref
      {
      private:
        typedef typename element<N, Tuple>::RET elt_type;
      public:
        typedef typename add_reference<elt_type>::type RET;
@ -236,89 +379,99 @@ namespace boost {
      // Return a const reference to the Nth type of the given Tuple
      template<int N, typename Tuple>
-      struct tuple_element_const_ref
+      struct element_const_ref
      {
      private:
-        typedef typename tuple_element<N, Tuple>::RET elt_type;
+        typedef typename element<N, Tuple>::RET elt_type;
      public:
        typedef typename add_reference<const elt_type>::type RET;
        typedef RET type;
      };
-    }
+#endif // vc7
-    }
+
    } // namespace detail
    // Get length of this tuple
    template<typename Tuple>
-    struct tuple_length
+    struct length
    {
-      enum { value = 1 + tuple_length<typename Tuple::tail_type>::value };
+      BOOST_STATIC_CONSTANT(int, value = 1 + length<typename Tuple::tail_type>::value);
    };
    template<> struct length<tuple<> > {
      BOOST_STATIC_CONSTANT(int, value = 0);
    };
    template<>
-    struct tuple_length<null_type>
+    struct length<null_type>
    {
-      enum { value = 0 };
+      BOOST_STATIC_CONSTANT(int, value = 0);
    };
    namespace detail {
    // Reference the Nth element in a tuple and retrieve it with "get"
    template<int N>
-    struct element
+    struct get_class
    {
-      template<typename Tuple>
+      template<typename Head, typename Tail>
      static inline
-      typename detail::tuples::tuple_element_ref<N, Tuple>::RET
+      typename detail::element_ref<N, cons<Head, Tail> >::RET
-      get(Tuple& t)
+      get(cons<Head, Tail>& t)
      {
-        return element<N-1>::get(t.tail);
+        return get_class<N-1>::get(t.tail);
      }
-      template<typename Tuple>
+      template<typename Head, typename Tail>
      static inline
-      typename detail::tuples::tuple_element_const_ref<N, Tuple>::RET
+      typename detail::element_const_ref<N, cons<Head, Tail> >::RET
-      get(const Tuple& t)
+      get(const cons<Head, Tail>& t)
      {
-        return element<N-1>::get(t.tail);
+        return get_class<N-1>::get(t.tail);
      }
    };
    template<>
-    struct element<0>
+    struct get_class<0>
    {
-      template<typename Tuple>
+      template<typename Head, typename Tail>
      static inline
-      typename add_reference<typename Tuple::head_type>::type
+      typename add_reference<Head>::type
-      get(Tuple& t)
+      get(cons<Head, Tail>& t)
      {
        return t.head;
      }
-      template<typename Tuple>
+      template<typename Head, typename Tail>
      static inline
-      typename add_reference<const typename Tuple::head_type>::type
+      typename add_reference<const Head>::type
-      get(const Tuple& t)
+      get(const cons<Head, Tail>& t)
      {
        return t.head;
      }
    };
    } // namespace detail
    // tuple class
    template<
-      typename T1, 
+      typename T1,
-      typename T2 = null_type, 
+      typename T2,
-      typename T3 = null_type, 
+      typename T3,
-      typename T4 = null_type,
+      typename T4,
-      typename T5 = null_type,
+      typename T5,
-      typename T6 = null_type,
+      typename T6,
-      typename T7 = null_type,
+      typename T7,
-      typename T8 = null_type,
+      typename T8,
-      typename T9 = null_type,
+      typename T9,
-      typename T10 = null_type
+      typename T10
    >
-    class tuple : 
+    class tuple :
-      public detail::tuples::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
+      public detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
    {
    private:
-      typedef detail::tuples::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> mapped_tuple;
+      typedef detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> mapped_tuple;
      typedef typename mapped_tuple::cons10 cons10;
      typedef typename mapped_tuple::cons9 cons9;
      typedef typename mapped_tuple::cons8 cons8;
@ -330,53 +483,87 @@ namespace boost {
      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(), 
+      tuple() : cons1(T1(), cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
-                     const T2& t2 = T2(),
+        {}
-                     const T3& t3 = T3(),
+
-                     const T4& t4 = T4(),
+      tuple(
-                     const T5& t5 = T5(),
+          t1_cref t1,
-                     const T6& t6 = T6(),
+          t2_cref t2,
-                     const T7& t7 = T7(),
+          t3_cref t3 = T3(),
-                     const T8& t8 = T8(),
+          t4_cref t4 = T4(),
-                     const T9& t9 = T9(),
+          t5_cref t5 = T5(),
-                     const T10& t10 = T10()) :
+          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))))))))))
      {
      }
-      template<typename Other>
+      explicit tuple(t1_cref t1)
-      explicit tuple(const Other& other) : cons1(other)
+        : cons1(t1, cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
      {}
      template<typename Head, typename Tail>
      tuple(const cons<Head, Tail>& other) :
        cons1(other.head, other.tail)
      {
      }
-      template<typename Other>
+      template<typename First, typename Second>
-      self_type& operator=(const Other& other)
+      self_type& operator=(const std::pair<First, Second>& other)
      {
        this->head = other.first;
        this->tail.head = other.second;
        return *this;
      }
      template<typename Head, typename Tail>
      self_type& operator=(const cons<Head, Tail>& other)
      {
        this->head = other.head;
        this->tail = other.tail;
        return *this;
      }
    };
-    // Retrieve the Nth element in the typle
+    namespace detail {
-    template<int N, typename Tuple>
+
-    typename detail::tuples::tuple_element_ref<N, Tuple>::RET
+      template<int N> struct workaround_holder {};
-    get(Tuple& t)
+
    } // namespace detail
    template<int N, typename Head, typename Tail>
    typename detail::element_ref<N, cons<Head, Tail> >::RET
    get(cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
    {
-      return element<N>::get(t);
+      return detail::get_class<N>::get(t);
    }
-    // Retrieve the Nth element in the typle
+    template<int N, typename Head, typename Tail>
-    template<int N, typename Tuple>
+    typename detail::element_const_ref<N, cons<Head, Tail> >::RET
-    typename detail::tuples::tuple_element_const_ref<N, Tuple>::RET
+    get(const cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
    get(const Tuple& t) 
    {
-      return element<N>::get(t);
+      return detail::get_class<N>::get(t);
    }
-     
+
    // Make a tuple
    template<typename T1>
    inline
@ -430,7 +617,7 @@ namespace boost {
    {
      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
@ -470,185 +657,185 @@ namespace boost {
    // Tie variables into a tuple
    template<typename T1>
    inline
-    tuple<detail::tuples::assign_to_pointee<T1> >
+    tuple<detail::assign_to_pointee<T1> >
    tie(T1& t1)
    {
-      return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1));
+      return make_tuple(detail::assign_to_pointee<T1>(&t1));
    }
    // Tie variables into a tuple
    template<typename T1, typename T2>
    inline
-    tuple<detail::tuples::assign_to_pointee<T1>, 
+    tuple<detail::assign_to_pointee<T1>,
-      detail::tuples::assign_to_pointee<T2> >
+      detail::assign_to_pointee<T2> >
    tie(T1& t1, T2& t2)
    {
-      return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
+      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::tuples::assign_to_pointee<T2>(&t2));
+                        detail::assign_to_pointee<T2>(&t2));
    }
    // Tie variables into a tuple
    template<typename T1, typename T2, typename T3>
    inline
-    tuple<detail::tuples::assign_to_pointee<T1>, 
+    tuple<detail::assign_to_pointee<T1>,
-      detail::tuples::assign_to_pointee<T2>, 
+      detail::assign_to_pointee<T2>,
-      detail::tuples::assign_to_pointee<T3> >
+      detail::assign_to_pointee<T3> >
    tie(T1& t1, T2& t2, T3& t3)
    {
-      return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
+      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::tuples::assign_to_pointee<T2>(&t2),
+                        detail::assign_to_pointee<T2>(&t2),
-                        detail::tuples::assign_to_pointee<T3>(&t3));
+                        detail::assign_to_pointee<T3>(&t3));
    }
    // Tie variables into a tuple
    template<typename T1, typename T2, typename T3, typename T4>
    inline
-    tuple<detail::tuples::assign_to_pointee<T1>, 
+    tuple<detail::assign_to_pointee<T1>,
-      detail::tuples::assign_to_pointee<T2>, 
+      detail::assign_to_pointee<T2>,
-      detail::tuples::assign_to_pointee<T3>, 
+      detail::assign_to_pointee<T3>,
-      detail::tuples::assign_to_pointee<T4> >
+      detail::assign_to_pointee<T4> >
    tie(T1& t1, T2& t2, T3& t3, T4& t4)
    {
-      return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
+      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::tuples::assign_to_pointee<T2>(&t2),
+                        detail::assign_to_pointee<T2>(&t2),
-                        detail::tuples::assign_to_pointee<T3>(&t3),
+                        detail::assign_to_pointee<T3>(&t3),
-                        detail::tuples::assign_to_pointee<T4>(&t4));
+                        detail::assign_to_pointee<T4>(&t4));
    }
    // Tie variables into a tuple
    template<typename T1, typename T2, typename T3, typename T4, typename T5>
    inline
-    tuple<detail::tuples::assign_to_pointee<T1>, 
+    tuple<detail::assign_to_pointee<T1>,
-      detail::tuples::assign_to_pointee<T2>, 
+      detail::assign_to_pointee<T2>,
-      detail::tuples::assign_to_pointee<T3>, 
+      detail::assign_to_pointee<T3>,
-      detail::tuples::assign_to_pointee<T4>, 
+      detail::assign_to_pointee<T4>,
-      detail::tuples::assign_to_pointee<T5> >
+      detail::assign_to_pointee<T5> >
    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5)
    {
-      return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
+      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::tuples::assign_to_pointee<T2>(&t2),
+                        detail::assign_to_pointee<T2>(&t2),
-                        detail::tuples::assign_to_pointee<T3>(&t3),
+                        detail::assign_to_pointee<T3>(&t3),
-                        detail::tuples::assign_to_pointee<T4>(&t4),
+                        detail::assign_to_pointee<T4>(&t4),
-                        detail::tuples::assign_to_pointee<T5>(&t5));
+                        detail::assign_to_pointee<T5>(&t5));
    }
    // Tie variables into a tuple
    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
    inline
-    tuple<detail::tuples::assign_to_pointee<T1>, 
+    tuple<detail::assign_to_pointee<T1>,
-      detail::tuples::assign_to_pointee<T2>, 
+      detail::assign_to_pointee<T2>,
-      detail::tuples::assign_to_pointee<T3>, 
+      detail::assign_to_pointee<T3>,
-      detail::tuples::assign_to_pointee<T4>, 
+      detail::assign_to_pointee<T4>,
-      detail::tuples::assign_to_pointee<T5>, 
+      detail::assign_to_pointee<T5>,
-      detail::tuples::assign_to_pointee<T6> >
+      detail::assign_to_pointee<T6> >
    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6)
    {
-      return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
+      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::tuples::assign_to_pointee<T2>(&t2),
+                        detail::assign_to_pointee<T2>(&t2),
-                        detail::tuples::assign_to_pointee<T3>(&t3),
+                        detail::assign_to_pointee<T3>(&t3),
-                        detail::tuples::assign_to_pointee<T4>(&t4),
+                        detail::assign_to_pointee<T4>(&t4),
-                        detail::tuples::assign_to_pointee<T6>(&t5),
+                        detail::assign_to_pointee<T5>(&t5),
-                        detail::tuples::assign_to_pointee<T5>(&t6));
+                        detail::assign_to_pointee<T6>(&t6));
    }
    // Tie variables into a tuple
    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
    inline
-    tuple<detail::tuples::assign_to_pointee<T1>, 
+    tuple<detail::assign_to_pointee<T1>,
-      detail::tuples::assign_to_pointee<T2>, 
+      detail::assign_to_pointee<T2>,
-      detail::tuples::assign_to_pointee<T3>, 
+      detail::assign_to_pointee<T3>,
-      detail::tuples::assign_to_pointee<T4>, 
+      detail::assign_to_pointee<T4>,
-      detail::tuples::assign_to_pointee<T5>, 
+      detail::assign_to_pointee<T5>,
-      detail::tuples::assign_to_pointee<T6>, 
+      detail::assign_to_pointee<T6>,
-      detail::tuples::assign_to_pointee<T7> >
+      detail::assign_to_pointee<T7> >
    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7)
    {
-      return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
+      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::tuples::assign_to_pointee<T2>(&t2),
+                        detail::assign_to_pointee<T2>(&t2),
-                        detail::tuples::assign_to_pointee<T3>(&t3),
+                        detail::assign_to_pointee<T3>(&t3),
-                        detail::tuples::assign_to_pointee<T4>(&t4),
+                        detail::assign_to_pointee<T4>(&t4),
-                        detail::tuples::assign_to_pointee<T5>(&t5),
+                        detail::assign_to_pointee<T5>(&t5),
-                        detail::tuples::assign_to_pointee<T6>(&t6),
+                        detail::assign_to_pointee<T6>(&t6),
-                        detail::tuples::assign_to_pointee<T7>(&t7));
+                        detail::assign_to_pointee<T7>(&t7));
    }
    // 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::tuples::assign_to_pointee<T1>, 
+    tuple<detail::assign_to_pointee<T1>,
-      detail::tuples::assign_to_pointee<T2>, 
+      detail::assign_to_pointee<T2>,
-      detail::tuples::assign_to_pointee<T3>, 
+      detail::assign_to_pointee<T3>,
-      detail::tuples::assign_to_pointee<T4>, 
+      detail::assign_to_pointee<T4>,
-      detail::tuples::assign_to_pointee<T5>, 
+      detail::assign_to_pointee<T5>,
-      detail::tuples::assign_to_pointee<T6>, 
+      detail::assign_to_pointee<T6>,
-      detail::tuples::assign_to_pointee<T7>, 
+      detail::assign_to_pointee<T7>,
-      detail::tuples::assign_to_pointee<T8> >
+      detail::assign_to_pointee<T8> >
    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8)
    {
-      return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
+      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::tuples::assign_to_pointee<T2>(&t2),
+                        detail::assign_to_pointee<T2>(&t2),
-                        detail::tuples::assign_to_pointee<T3>(&t3),
+                        detail::assign_to_pointee<T3>(&t3),
-                        detail::tuples::assign_to_pointee<T4>(&t4),
+                        detail::assign_to_pointee<T4>(&t4),
-                        detail::tuples::assign_to_pointee<T5>(&t5),
+                        detail::assign_to_pointee<T5>(&t5),
-                        detail::tuples::assign_to_pointee<T6>(&t6),
+                        detail::assign_to_pointee<T6>(&t6),
-                        detail::tuples::assign_to_pointee<T7>(&t7),
+                        detail::assign_to_pointee<T7>(&t7),
-                        detail::tuples::assign_to_pointee<T8>(&t8));
+                        detail::assign_to_pointee<T8>(&t8));
    }
    // 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::tuples::assign_to_pointee<T1>, 
+    tuple<detail::assign_to_pointee<T1>,
-      detail::tuples::assign_to_pointee<T2>, 
+      detail::assign_to_pointee<T2>,
-      detail::tuples::assign_to_pointee<T3>, 
+      detail::assign_to_pointee<T3>,
-      detail::tuples::assign_to_pointee<T4>, 
+      detail::assign_to_pointee<T4>,
-      detail::tuples::assign_to_pointee<T5>, 
+      detail::assign_to_pointee<T5>,
-      detail::tuples::assign_to_pointee<T6>, 
+      detail::assign_to_pointee<T6>,
-      detail::tuples::assign_to_pointee<T7>, 
+      detail::assign_to_pointee<T7>,
-      detail::tuples::assign_to_pointee<T8>, 
+      detail::assign_to_pointee<T8>,
-      detail::tuples::assign_to_pointee<T9> >
+      detail::assign_to_pointee<T9> >
    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9)
    {
-      return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
+      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::tuples::assign_to_pointee<T2>(&t2),
+                        detail::assign_to_pointee<T2>(&t2),
-                        detail::tuples::assign_to_pointee<T3>(&t3),
+                        detail::assign_to_pointee<T3>(&t3),
-                        detail::tuples::assign_to_pointee<T4>(&t4),
+                        detail::assign_to_pointee<T4>(&t4),
-                        detail::tuples::assign_to_pointee<T5>(&t5),
+                        detail::assign_to_pointee<T5>(&t5),
-                        detail::tuples::assign_to_pointee<T6>(&t6),
+                        detail::assign_to_pointee<T6>(&t6),
-                        detail::tuples::assign_to_pointee<T7>(&t7),
+                        detail::assign_to_pointee<T7>(&t7),
-                        detail::tuples::assign_to_pointee<T8>(&t8),
+                        detail::assign_to_pointee<T8>(&t8),
-                        detail::tuples::assign_to_pointee<T9>(&t9));
+                        detail::assign_to_pointee<T9>(&t9));
    }
    // 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::tuples::assign_to_pointee<T1>, 
+    tuple<detail::assign_to_pointee<T1>,
-      detail::tuples::assign_to_pointee<T2>, 
+      detail::assign_to_pointee<T2>,
-      detail::tuples::assign_to_pointee<T3>, 
+      detail::assign_to_pointee<T3>,
-      detail::tuples::assign_to_pointee<T4>, 
+      detail::assign_to_pointee<T4>,
-      detail::tuples::assign_to_pointee<T5>, 
+      detail::assign_to_pointee<T5>,
-      detail::tuples::assign_to_pointee<T6>, 
+      detail::assign_to_pointee<T6>,
-      detail::tuples::assign_to_pointee<T7>, 
+      detail::assign_to_pointee<T7>,
-      detail::tuples::assign_to_pointee<T8>, 
+      detail::assign_to_pointee<T8>,
-      detail::tuples::assign_to_pointee<T9>, 
+      detail::assign_to_pointee<T9>,
-      detail::tuples::assign_to_pointee<T10> >
+      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)
    {
-      return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
+      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::tuples::assign_to_pointee<T2>(&t2),
+                        detail::assign_to_pointee<T2>(&t2),
-                        detail::tuples::assign_to_pointee<T3>(&t3),
+                        detail::assign_to_pointee<T3>(&t3),
-                        detail::tuples::assign_to_pointee<T4>(&t4),
+                        detail::assign_to_pointee<T4>(&t4),
-                        detail::tuples::assign_to_pointee<T5>(&t5),
+                        detail::assign_to_pointee<T5>(&t5),
-                        detail::tuples::assign_to_pointee<T6>(&t6),
+                        detail::assign_to_pointee<T6>(&t6),
-                        detail::tuples::assign_to_pointee<T7>(&t7),
+                        detail::assign_to_pointee<T7>(&t7),
-                        detail::tuples::assign_to_pointee<T8>(&t8),
+                        detail::assign_to_pointee<T8>(&t8),
-                        detail::tuples::assign_to_pointee<T9>(&t9),
+                        detail::assign_to_pointee<T9>(&t9),
-                        detail::tuples::assign_to_pointee<T10>(&t10));
+                        detail::assign_to_pointee<T10>(&t10));
    }
    // "ignore" allows tuple positions to be ignored when using "tie". 
    namespace {
      detail::tuples::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
 #endif // BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
--- a/include/boost/tuple/reference_wrappers.hpp
+++ b/include/boost/tuple/reference_wrappers.hpp
@ -1,57 +0,0 @@
 // -- reference_wrappers - Boost Tuple Library -----------------------------
 // Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //
 // Permission to copy, use, sell and distribute this software is granted
 // provided this copyright notice appears in all copies. 
 // Permission to modify the code and to distribute modified code is granted
 // provided this copyright notice appears in all copies, and a notice 
 // that the code was modified is included with the copyright notice.
 //
 // This software is provided "as is" without express or implied warranty, 
 // and with no claim as to its suitability for any purpose.
 //
 // For more information, see http://www.boost.org 
 // ----------------------------------------------------------------- 
 #ifndef BOOST_TUPLE_REFERENCE_WRAPPERS_HPP
 #define BOOST_TUPLE_REFERENCE_WRAPPERS_HPP
 namespace boost {
 // reference wrappers -------------------------------------------------------
 // These wrappers are handle classes that hold references to objects.
 // reference_wrapper is used to specify that a tuple element should be 
 // a reference to the wrapped object - rather than a copy of it.
 // The wrapper acts as a disguise for passing non-const reference 
 // parameters via a reference to const parameter.
 template<class T>
 class reference_wrapper { 
  T& x; 
 public:
  explicit 
  reference_wrapper(T& t) : x(t) {} 
  operator T&() const { return x; }
 };
 // store as a reference to T
 template<class T> 
 inline const reference_wrapper<T> ref(T& t) { 
  return reference_wrapper<T>(t); 
 }
 // store as a reference to const T
 template<class T> 
 inline const reference_wrapper<const T> cref(const T& t) {
  return reference_wrapper<const T>(t); 
 }
 } // end of namespace boost
 #endif	// BOOST_TUPLE_REFERENCE_WRAPPERS_HPP
--- a/include/boost/tuple/tuple.hpp
+++ b/include/boost/tuple/tuple.hpp
@ -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
+// Distributed under the Boost Software License, Version 1.0. (See
-// provided this copyright notice appears in all copies. 
+// accompanying file LICENSE_1_0.txt or copy at
-// Permission to modify the code and to distribute modified code is granted
+// http://www.boost.org/LICENSE_1_0.txt)
 // provided this copyright notice appears in all copies, and a notice 
 // that the code was modified is included with the copyright notice.
 //
 // This software is provided "as is" without express or implied warranty, 
 // and with no claim as to its suitability for any purpose.
 // For more information, see http://www.boost.org
@ -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"
@ -27,10 +29,62 @@
 #else
 // other compilers
-#include "boost/tuple/reference_wrappers.hpp"
+#include "boost/ref.hpp"
 #include "boost/tuple/detail/tuple_basic.hpp"
 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 namespace boost {    
-#endif	// BOOST_TUPLE_HPP
+using tuples::tuple;
 using tuples::make_tuple;
 using tuples::tie;
 #if !defined(BOOST_NO_USING_TEMPLATE)
 using tuples::get;
 #elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 //
 // The "using tuples::get" statement causes the
 // Borland compiler to ICE, use forwarding
 // functions instead:
 //
 template<int N, class HT, class TT>
 inline typename tuples::access_traits<
                  typename tuples::element<N, tuples::cons<HT, TT> >::type
                >::non_const_type
 get(tuples::cons<HT, TT>& c) {
  return tuples::get<N,HT,TT>(c);
 } 
 // get function for const cons-lists, returns a const reference to
 // the element. If the element is a reference, returns the reference
 // as such (that is, can return a non-const reference)
 template<int N, class HT, class TT>
 inline typename tuples::access_traits<
                  typename tuples::element<N, tuples::cons<HT, TT> >::type
                >::const_type
 get(const tuples::cons<HT, TT>& c) {
  return tuples::get<N,HT,TT>(c);
 }
 #else  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 //
 // MSVC, using declarations don't mix with templates well,
 // so use forwarding functions instead:
 //
 template<int N, typename Head, typename Tail>
 typename tuples::detail::element_ref<N, tuples::cons<Head, Tail> >::RET
 get(tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0)
 {
   return tuples::detail::get_class<N>::get(t);
 }
 template<int N, typename Head, typename Tail>
 typename tuples::detail::element_const_ref<N, tuples::cons<Head, Tail> >::RET
 get(const tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0)
 {
   return tuples::detail::get_class<N>::get(t);
 }
 #endif // BOOST_NO_USING_TEMPLATE
 } // end namespace boost
 #endif // BOOST_TUPLE_HPP
--- 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
+// Distributed under the Boost Software License, Version 1.0. (See
-// provided this copyright notice appears in all copies. 
+// accompanying file LICENSE_1_0.txt or copy at
-// Permission to modify the code and to distribute modified code is granted
+// http://www.boost.org/LICENSE_1_0.txt)
 // provided this copyright notice appears in all copies, and a notice 
 // that the code was modified is included with the copyright notice.
 // 
 // This software is provided "as is" without express or implied warranty, 
 // and with no claim as to its suitability for any purpose.
 // 
 // For more information, see http://www.boost.org
 // 
@ -38,6 +33,7 @@
 namespace boost {
 namespace tuples {
 inline bool operator==(const null_type&, const null_type&) { return true; }
 inline bool operator>=(const null_type&, const null_type&) { return true; }
@ -48,7 +44,6 @@ inline bool operator>(const null_type&, const null_type&) { return false; }
 namespace detail {
 namespace tuples {
  // comparison operators check statically the length of its operands and
  // delegate the comparing task to the following functions. Hence
  // the static check is only made once (should help the compiler).  
@ -69,7 +64,7 @@ inline bool neq(const T1& lhs, const T2& rhs) {
         neq(lhs.get_tail(), rhs.get_tail());
 }
 template<>
-inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return true; }
+inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return false; }
 template<class T1, class T2>
 inline bool lt(const T1& lhs, const T2& rhs) {
@ -107,7 +102,6 @@ inline bool gte(const T1& lhs, const T2& rhs) {
 template<>
 inline bool gte<null_type,null_type>(const null_type&, const null_type&) { return true; }
 } // end of namespace tuples
 } // end of namespace detail
@ -116,10 +110,10 @@ inline bool gte<null_type,null_type>(const null_type&, const null_type&) { retur
 template<class T1, class T2, class S1, class S2>
 inline bool operator==(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
 {
-  // check that tuple_lengths are equal
+  // check that tuple lengths are equal
-  BOOST_STATIC_ASSERT(tuple_length<T2>::value == tuple_length<S2>::value);
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
-  return  detail::tuples::eq(lhs, rhs);
+  return  detail::eq(lhs, rhs);
 }
 // not equal -----
@ -128,53 +122,54 @@ template<class T1, class T2, class S1, class S2>
 inline bool operator!=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
 {
-  // check that tuple_lengths are equal
+  // check that tuple lengths are equal
-  BOOST_STATIC_ASSERT(tuple_length<T2>::value == tuple_length<S2>::value);
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
-  return detail::tuples::neq(lhs, rhs);
+  return detail::neq(lhs, rhs);
 }
 // <
 template<class T1, class T2, class S1, class S2>
 inline bool operator<(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
 {
-  // check that tuple_lengths are equal
+  // check that tuple lengths are equal
-  BOOST_STATIC_ASSERT(tuple_length<T2>::value == tuple_length<S2>::value);
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
-  return detail::tuples::lt(lhs, rhs);
+  return detail::lt(lhs, rhs);
 }
 // >
 template<class T1, class T2, class S1, class S2>
 inline bool operator>(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
 {
-  // check that tuple_lengths are equal
+  // check that tuple lengths are equal
-  BOOST_STATIC_ASSERT(tuple_length<T2>::value == tuple_length<S2>::value);
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
-  return detail::tuples::gt(lhs, rhs);
+  return detail::gt(lhs, rhs);
 }
 // <=
 template<class T1, class T2, class S1, class S2>
 inline bool operator<=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
 {
-  // check that tuple_lengths are equal
+  // check that tuple lengths are equal
-  BOOST_STATIC_ASSERT(tuple_length<T2>::value == tuple_length<S2>::value);
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
-  return detail::tuples::lte(lhs, rhs);
+  return detail::lte(lhs, rhs);
 }
 // >=
 template<class T1, class T2, class S1, class S2>
 inline bool operator>=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
 {
-  // check that tuple_lengths are equal
+  // check that tuple lengths are equal
-  BOOST_STATIC_ASSERT(tuple_length<T2>::value == tuple_length<S2>::value);
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
-  return detail::tuples::gte(lhs, rhs);
+  return detail::gte(lhs, rhs);
 }
 } // end of namespace tuples
 } // end of namespace boost
-#endif	// BOOST_TUPLE_COMPARISON_HPP
+#endif // BOOST_TUPLE_COMPARISON_HPP
--- a/include/boost/tuple/tuple_io.hpp
+++ b/include/boost/tuple/tuple_io.hpp
@ -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
+// Distributed under the Boost Software License, Version 1.0. (See
-// provided this copyright notice appears in all copies. 
+// accompanying file LICENSE_1_0.txt or copy at
-// Permission to modify the code and to distribute modified code is granted
+// http://www.boost.org/LICENSE_1_0.txt)
 // provided this copyright notice appears in all copies, and a notice 
 // that the code was modified is included with the copyright notice.
 //
 // This software is provided "as is" without express or implied warranty, 
 // and with no claim as to its suitability for any purpose.
 // For more information, see http://www.boost.org 
 // ----------------------------------------------------------------------------
@ -25,7 +20,7 @@
 #   if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97) 
 #define BOOST_NO_TEMPLATED_STREAMS
 #endif
-#endif	// __GNUC__
+#endif // __GNUC__
 #if defined BOOST_NO_TEMPLATED_STREAMS
 #include <iostream>
@ -36,20 +31,43 @@
 #include "boost/tuple/tuple.hpp"
 // This is ugly: one should be using twoargument isspace since whitspace can
 // be locale dependent, in theory at least.
 // not all libraries implement have the two-arg version, so we need to 
 // use the one-arg one, which one should get with <cctype> but there seem
 // to be exceptions to this.
 #if !defined (BOOST_NO_STD_LOCALE)
 #include <locale> // for two-arg isspace
 #else 
 #include <cctype> // for one-arg (old) isspace 
 #include <ctype.h> // Metrowerks does not find one-arg isspace from cctype
 #endif
 namespace boost {
 namespace tuples {
 namespace detail {
 namespace tuples {
 class format_info {
 public:   
   enum manipulator_type { open, close, delimiter };
   BOOST_STATIC_CONSTANT(int, number_of_manipulators = delimiter + 1);
 private:
-   static const int stream_index[number_of_manipulators];
+   static int get_stream_index (int m)
   {
     static const int stream_index[number_of_manipulators]
        = { std::ios::xalloc(), std::ios::xalloc(), std::ios::xalloc() };
     return stream_index[m];
   }
   format_info(const format_info&);
   format_info();   
@ -58,21 +76,21 @@ public:
 #if defined (BOOST_NO_TEMPLATED_STREAMS)
   static char get_manipulator(std::ios& i, manipulator_type m) {
-     char c = static_cast<char>(i.iword(stream_index[m])); 
+     char c = static_cast<char>(i.iword(get_stream_index(m))); 
     // parentheses and space are the default manipulators
     if (!c) {
       switch(m) {
-         case open : c = '('; break;					    
+         case detail::format_info::open : c = '('; break;
-         case close : c = ')'; break;					    
+         case detail::format_info::close : c = ')'; break;
-         case delimiter : c = ' '; break;
+         case detail::format_info::delimiter : c = ' '; break;
       }
     }
     return c;
   }
   static void set_manipulator(std::ios& i, manipulator_type m, char c) {
-      i.iword(stream_index[m]) = static_cast<long>(c);
+      i.iword(get_stream_index(m)) = static_cast<long>(c);
   }
 #else
   template<class CharType, class CharTrait>
@ -82,13 +100,13 @@ public:
     // A valid instanitation of basic_stream allows CharType to be any POD,
     // hence, the static_cast may fail (it fails if long is not convertible 
     // to CharType
-     CharType c = static_cast<CharType>(i.iword(stream_index[m]) ); 
+     CharType c = static_cast<CharType>(i.iword(get_stream_index(m)) ); 
     // parentheses and space are the default manipulators
     if (!c) {
       switch(m) {
-         case open :  c = i.widen('('); break;					    
+         case detail::format_info::open :  c = i.widen('('); break;
-         case close : c = i.widen(')'); break;					    
+         case detail::format_info::close : c = i.widen(')'); break;
-         case delimiter : c = i.widen(' '); break;
+         case detail::format_info::delimiter : c = i.widen(' '); break;
       }
     }
     return c;
@ -102,51 +120,50 @@ public:
     // A valid instanitation of basic_stream allows CharType to be any POD,
     // hence, the static_cast may fail (it fails if CharType is not 
     // convertible long.
-      i.iword(stream_index[m]) = static_cast<long>(c);
+      i.iword(get_stream_index(m)) = static_cast<long>(c);
   }
-#endif	// BOOST_NO_TEMPLATED_STREAMS
+#endif // BOOST_NO_TEMPLATED_STREAMS
 };
 } // end of namespace detail
 template<class CharType>    
 class tuple_manipulator {
-  const format_info::manipulator_type mt;
+  const detail::format_info::manipulator_type mt;
  CharType f_c;
 public:
-  explicit tuple_manipulator(format_info::manipulator_type m, const char c = 0)
+  explicit tuple_manipulator(detail::format_info::manipulator_type m, 
                             const char c = 0)
     : mt(m), f_c(c) {}
 #if defined (BOOST_NO_TEMPLATED_STREAMS)
  void set(std::ios &io) const {
-     format_info::set_manipulator(io, mt, f_c);
+     detail::format_info::set_manipulator(io, mt, f_c);
  }
 #else
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   template<class CharType2, class CharTrait>
  void set(std::basic_ios<CharType2, CharTrait> &io) const {
-     format_info::set_manipulator(io, mt, f_c);
+     detail::format_info::set_manipulator(io, mt, f_c);
  }
 #else
   template<class CharTrait>
  void set(std::basic_ios<CharType, CharTrait> &io) const {
-     format_info::set_manipulator(io, mt, f_c);
+     detail::format_info::set_manipulator(io, mt, f_c);
  }
-#endif	// BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#endif	// BOOST_NO_TEMPLATED_STREAMS
+#endif // BOOST_NO_TEMPLATED_STREAMS
 };
 } // end of namespace tuples
 } // end of namespace detail
 #if defined (BOOST_NO_TEMPLATED_STREAMS)
 inline std::ostream&
-operator<<(std::ostream& o, const detail::tuples::tuple_manipulator<char>& m) {
+operator<<(std::ostream& o, const tuple_manipulator<char>& m) {
  m.set(o);
  return o;
 }
 inline std::istream&
-operator>>(std::istream& i, const detail::tuples::tuple_manipulator<char>& m) {
+operator>>(std::istream& i, const tuple_manipulator<char>& m) {
  m.set(i);
  return i;
 }
@ -155,14 +172,14 @@ operator>>(std::istream& i, const detail::tuples::tuple_manipulator<char>& m) {
 template<class CharType, class CharTrait>
 inline std::basic_ostream<CharType, CharTrait>&
-operator<<(std::basic_ostream<CharType, CharTrait>& o, const detail::tuples::tuple_manipulator<CharType>& m) {
+operator<<(std::basic_ostream<CharType, CharTrait>& o, const tuple_manipulator<CharType>& m) {
  m.set(o);
  return o;
 }
 template<class CharType, class CharTrait>
 inline std::basic_istream<CharType, CharTrait>&
-operator>>(std::basic_istream<CharType, CharTrait>& i, const detail::tuples::tuple_manipulator<CharType>& m) {
+operator>>(std::basic_istream<CharType, CharTrait>& i, const tuple_manipulator<CharType>& m) {
  m.set(i);
  return i;
 }
@ -170,18 +187,18 @@ operator>>(std::basic_istream<CharType, CharTrait>& i, const detail::tuples::tup
 #endif   // BOOST_NO_TEMPLATED_STREAMS
 template<class CharType>
-inline detail::tuples::tuple_manipulator<CharType> set_open(const CharType c) {
+inline tuple_manipulator<CharType> set_open(const CharType c) {
-   return detail::tuples::tuple_manipulator<CharType>(detail::tuples::format_info::open, c);
+   return tuple_manipulator<CharType>(detail::format_info::open, c);
 }
 template<class CharType>
-inline detail::tuples::tuple_manipulator<CharType> set_close(const CharType c) {
+inline tuple_manipulator<CharType> set_close(const CharType c) {
-   return detail::tuples::tuple_manipulator<CharType>(detail::tuples::format_info::close, c);
+   return tuple_manipulator<CharType>(detail::format_info::close, c);
 }
 template<class CharType>
-inline detail::tuples::tuple_manipulator<CharType> set_delimiter(const CharType c) {
+inline tuple_manipulator<CharType> set_delimiter(const CharType c) {
-   return detail::tuples::tuple_manipulator<CharType>(detail::tuples::format_info::delimiter, c);
+   return tuple_manipulator<CharType>(detail::format_info::delimiter, c);
 }
@ -194,7 +211,6 @@ inline detail::tuples::tuple_manipulator<CharType> set_delimiter(const CharType
 // set_open, set_close and set_delimiter
 namespace detail {
 namespace tuples {
 // Note: The order of the print functions is critical 
 // to let a conforming compiler  find and select the correct one.
@ -206,7 +222,7 @@ template<class T1>
 inline std::ostream& print(std::ostream& o, const cons<T1, null_type>& t) {
  return o << t.head;
 }
-#endif	// BOOST_NO_TEMPLATED_STREAMS
+#endif // BOOST_NO_TEMPLATED_STREAMS
 inline std::ostream& print(std::ostream& o, const null_type&) { return o; }
@ -219,8 +235,8 @@ print(std::ostream& o, const cons<T1, T2>& t) {
  o << t.head;
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  if (tuple_length<T2>::value == 0)
+  if (tuples::length<T2>::value == 0)
-	return o;
+    return o;
 #endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
  o << d;
@ -256,17 +272,16 @@ print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, T2>& t) {
  o << t.head;
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  if (tuple_length<T2>::value == 0)
+  if (tuples::length<T2>::value == 0)
-	return o;
+    return o;
 #endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
  o << d;
  return print(o, t.tail);
 }
-#endif	// BOOST_NO_TEMPLATED_STREAMS
+#endif  // BOOST_NO_TEMPLATED_STREAMS
 } // namespace tuples
 } // namespace detail
 #if defined (BOOST_NO_TEMPLATED_STREAMS)
@ -275,13 +290,13 @@ inline std::ostream& operator<<(std::ostream& o, const cons<T1, T2>& t) {
  if (!o.good() ) return o;
  const char l = 
-    detail::tuples::format_info::get_manipulator(o, detail::tuples::format_info::open);
+    detail::format_info::get_manipulator(o, detail::format_info::open);
  const char r = 
-    detail::tuples::format_info::get_manipulator(o, detail::tuples::format_info::close);
+    detail::format_info::get_manipulator(o, detail::format_info::close);
  o << l;
-  detail::tuples::print(o, t);  
+  detail::print(o, t);  
  o << r;
@ -297,26 +312,25 @@ operator<<(std::basic_ostream<CharType, CharTrait>& o,
  if (!o.good() ) return o;
  const CharType l = 
-    detail::tuples::format_info::get_manipulator(o, detail::tuples::format_info::open);
+    detail::format_info::get_manipulator(o, detail::format_info::open);
  const CharType r = 
-    detail::tuples::format_info::get_manipulator(o, detail::tuples::format_info::close);
+    detail::format_info::get_manipulator(o, detail::format_info::close);
  o << l;   
-  detail::tuples::print(o, t);  
+  detail::print(o, t);  
  o << r;
  return o;
 }
-#endif	// BOOST_NO_TEMPLATED_STREAMS
+#endif // BOOST_NO_TEMPLATED_STREAMS
 // -------------------------------------------------------------
 // input stream operators
 namespace detail {
 namespace tuples {
 #if defined (BOOST_NO_TEMPLATED_STREAMS)
@ -326,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);
    } 
  }
@ -353,7 +371,7 @@ read (std::istream &is, cons<T1, null_type>& t1) {
 }
 #else
 inline std::istream& read(std::istream& i, const null_type&) { return i; }
-#endif	// !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template<class T1, class T2>
 inline std::istream& 
@ -364,8 +382,8 @@ read(std::istream &is, cons<T1, T2>& t1) {
  is >> t1.head;
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  if (tuple_length<T2>::value == 0)
+  if (tuples::length<T2>::value == 0)
-	return is;
+    return is;
 #endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
  extract_and_check_delimiter(is, format_info::delimiter);
@ -373,7 +391,6 @@ read(std::istream &is, cons<T1, T2>& t1) {
  return read(is, t1.tail);
 }
 } // end namespace tuples
 } // end namespace detail
 inline std::istream& 
@ -381,8 +398,8 @@ operator>>(std::istream &is, null_type&) {
  if (!is.good() ) return is;
-  detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::open);
+  detail::extract_and_check_delimiter(is, detail::format_info::open);
-  detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::close);
+  detail::extract_and_check_delimiter(is, detail::format_info::close);
  return is;
 }
@ -394,11 +411,11 @@ operator>>(std::istream& is, cons<T1, T2>& t1) {
  if (!is.good() ) return is;
-  detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::open);
+  detail::extract_and_check_delimiter(is, detail::format_info::open);
-  detail::tuples::read(is, t1);
+  detail::read(is, t1);
-  detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::close);
+  detail::extract_and_check_delimiter(is, detail::format_info::close);
  return is;
 }
@ -414,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);
    }
  }
@ -441,7 +465,7 @@ template<class CharType, class CharTrait>
 inline std::basic_istream<CharType, CharTrait>& 
 read(std::basic_istream<CharType, CharTrait>& i, const null_type&) { return i; }
-#endif	// !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template<class CharType, class CharTrait, class T1, class T2>
 inline std::basic_istream<CharType, CharTrait>& 
@ -452,8 +476,8 @@ read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) {
  is >> t1.head;
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  if (tuple_length<T2>::value == 0)
+  if (tuples::length<T2>::value == 0)
-	return is;
+    return is;
 #endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
  extract_and_check_delimiter(is, format_info::delimiter);
@ -461,7 +485,6 @@ read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) {
  return read(is, t1.tail);
 }
 } // end namespace tuples
 } // end namespace detail
@ -471,8 +494,8 @@ operator>>(std::basic_istream<CharType, CharTrait> &is, null_type&) {
  if (!is.good() ) return is;
-  detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::open);
+  detail::extract_and_check_delimiter(is, detail::format_info::open);
-  detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::close);
+  detail::extract_and_check_delimiter(is, detail::format_info::close);
  return is;
 }
@ -483,19 +506,20 @@ operator>>(std::basic_istream<CharType, CharTrait>& is, cons<T1, T2>& t1) {
  if (!is.good() ) return is;
-  detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::open);
+  detail::extract_and_check_delimiter(is, detail::format_info::open);
-  detail::tuples::read(is, t1);
+  detail::read(is, t1);
-  detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::close);
+  detail::extract_and_check_delimiter(is, detail::format_info::close);
  return is;
 }
-#endif	// BOOST_NO_TEMPLATED_STREAMS
+#endif // BOOST_NO_TEMPLATED_STREAMS
 } // end of namespace tuples
 } // end of namespace boost
-#endif	// BOOST_TUPLE_IO_HPP
+#endif // BOOST_TUPLE_IO_HPP
--- a/index.html
+++ b/index.html
@ -0,0 +1,13 @@
 <html>
 <head>
 <meta http-equiv="refresh" content="0; URL=doc/tuple_users_guide.html">
 </head>
 <body>
 Automatic redirection failed, please go to <a href="doc/tuple_users_guide.html">doc/tuple_users_guide.html</a> 
 &nbsp;<hr>
 <p><EFBFBD> Copyright Beman Dawes, 2001</p>
 <p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
 file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
 at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
 </body>
 </html>
--- a/src/tuple.cpp
+++ b/src/tuple.cpp
@ -1,33 +0,0 @@
 //  tuple.cpp -----------------------------------------------------
 // Copyright (C) 1999, 2000, 2001 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
 //
 // Permission to copy, use, sell and distribute this software is granted
 // provided this copyright notice appears in all copies. 
 // Permission to modify the code and to distribute modified code is granted
 // provided this copyright notice appears in all copies, and a notice 
 // that the code was modified is included with the copyright notice.
 //
 // This software is provided "as is" without express or implied warranty, 
 // and with no claim as to its suitability for any purpose.
 // For more information, see http://lambda.cs.utu.fi 
 // Revision History 
 // 16 02 01 Initial Version (GWP)
 // ----------------------------------------------------------------- 
 #include "boost/tuple/tuple_io.hpp"
 namespace boost {
 namespace detail {
 namespace tuples {
 const int
 format_info::stream_index[number_of_manipulators] 
   = { std::ios::xalloc(), std::ios::xalloc(), std::ios::xalloc() };
 } // namespace tuples   
 } // namespace detail
 } // namespace boost
--- a/test/Jamfile
+++ b/test/Jamfile
@ -0,0 +1,8 @@
 project : requirements <library>/boost/test//boost_test_exec_monitor ;
 test-suite tuple : 
    [ run tuple_test_bench.cpp ]
    [ run io_test.cpp ]
    [ run another_tuple_test_bench.cpp ]
    ;
--- a/test/README
+++ b/test/README
@ -8,7 +8,9 @@ For example, in libs/tuple/test directory you would type (using g++):
 g++ -I../../.. tuple_test_bench.cpp
-If you want to use tuple_io, you need to compile and link src/tuple.cpp:
+The following is not true anymore:
-g++ -I../../.. ../src/tuple.cpp io_test.cpp
+  If you want to use tuple_io, you need to compile and link src/tuple.cpp:
  g++ -I../../.. ../src/tuple.cpp io_test.cpp
 Thanks to Hartmut Kaiser's suggestion, the tuple.cpp is not needed anymore.
--- a/test/another_tuple_test_bench.cpp
+++ b/test/another_tuple_test_bench.cpp
@ -1,5 +1,17 @@
-//  tuple_test_bench.cpp  --------------------------------
+// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // For more information, see http://www.boost.org
 //  another_test_bench.cpp  --------------------------------
 // This file has various tests to see that things that shouldn't
 // 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.
@ -8,156 +20,145 @@
 #include "boost/tuple/tuple.hpp"
-#include "boost/tuple/tuple_comparison.hpp"
+#include <string>
 #include <utility>
 using namespace std;
 using namespace boost;
 using namespace boost::tuples;
-class foo
+
-{
+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:
-  explicit foo(int v) : val(v) {}
+  no_copy() {};
  bool operator==(const foo& other) const
  {
    return val == other.val;
  }
 private:
  foo() {}
  int val;
 };
-void
+no_copy y;
 construction_test()
 {
  tuple<int> t1; 
  BOOST_TEST(get<0>(t1) == int());
  tuple<float> t2(5.5f);
  BOOST_TEST(get<0>(t2) == 5.5f);
-  tuple<foo> t3(foo(12));
+#ifdef E1
-  BOOST_TEST(get<0>(t3) == foo(12));
+tuple<no_copy> v1;  // should faild
 #endif
  tuple<double> t4(t2);
  BOOST_TEST(get<0>(t4) == 5.5);
-  tuple<int, float> t5;
+#ifdef E2
-  BOOST_TEST(get<0>(t5) == int());
+char cs[10];
-  BOOST_TEST(get<1>(t5) == float());
+tuple<char[10]> v3;  // should fail, arrays must be stored as references
 #endif
-  tuple<int, float> t6(12, 5.5f);
+// a class without a public default constructor
-  BOOST_TEST(get<0>(t6) == 12);
+class no_def_constructor {
-  BOOST_TEST(get<1>(t6) == 5.5f);
+  no_def_constructor() {}
 public:
  no_def_constructor(std::string) {} // can be constructed with a string
 };
-  tuple<long, double> t7(t6);
+void foo1() {
-  BOOST_TEST(get<0>(t7) == 12);
+
-  BOOST_TEST(get<1>(t7) == 5.5f);
+#ifdef E3
  dummy(tuple<no_def_constructor, no_def_constructor, no_def_constructor>()); 
  // should fail
 #endif
 }
-void
+void foo2() {
-copy_test()
+// testing default values
-{
+#ifdef E4
-  tuple<int, float> t1(4, 12.5f);
+  dummy(tuple<double&>()); // should fail, not defaults for references
-  tuple<int, float> t2(5, 2.2f);
+  dummy(tuple<const double&>()); // likewise
-  t2 = t1;
+#endif
  BOOST_TEST(get<0>(t1) == get<0>(t2));
  BOOST_TEST(get<1>(t1) == get<1>(t2));
  tuple<long, double> t3(2, 3.3);
  t3 = t1;
  BOOST_TEST((double)get<0>(t1) == get<0>(t3));
  BOOST_TEST((double)get<1>(t1) == get<1>(t3));
 }
 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.2f);
  BOOST_TEST(get<2>(t1) == false);
  BOOST_TEST(get<3>(t1) == foo(5));
 }
 void
 make_tuple_test()
 {
  tuple<int, float> t1 = make_tuple(5, 2.25f);
  BOOST_TEST(get<0>(t1) == 5);
  BOOST_TEST(get<1>(t1) == 2.25f);
  tuple<int, double> t2;
  t2 = make_tuple((short int)2, 2.25);
  BOOST_TEST(get<0>(t2) == 2);
  BOOST_TEST(get<1>(t2) == 2.25);
 }
 void
 tie_test()
 {
  int a;
  float b;
  foo c(5);
  tie(a, b, c) = make_tuple(2, 5.5f, foo(3));
  BOOST_TEST(a == 2);
  BOOST_TEST(b == 5.5f);
  BOOST_TEST(c == foo(3));
  tie(a, ignore, c) = make_tuple((short int)5, false, foo(5));
  BOOST_TEST(a == 5);
  BOOST_TEST(b == 5.5f);
  BOOST_TEST(c == foo(5));
 }
 void
 equality_test()
 {
  tuple<int, float> t1(5, 3.3f);
  tuple<int, float> t2(5, 3.3f);
  BOOST_TEST(t1 == t2);
  tuple<int, float> t3(5, 2.2f);
  tuple<int, float> t4(2, 3.3f);
  BOOST_TEST(t1 != t3);
  BOOST_TEST(t1 != t4);
 }
 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);
 #ifdef E5
  double dd = 5;
  dummy(tuple<double&>(dd+3.14)); // should fail, temporary to non-const reference
 #endif
 }
-int
+
-test_main(int, char *[])
+// 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() 
 {
-  construction_test();
+  double d = 2.7; 
-  copy_test();
+  A a;
-  mutate_test();
+  tuple<int, double&, const A&> t(1, d, a);
-  make_tuple_test();
+  const tuple<int, double&, const A> ct = t;
-  tie_test();
+  (void)ct;
-  equality_test();
+#ifdef E8
-  ordering_test();
+  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
 }
 // 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;
    (void)t;
    tuple<char, char> aaa;
    tuple<int, int> bbb(aaa);
    (void)bbb;
    //    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,3 +1,11 @@
 // Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // For more information, see http://www.boost.org
 // -- io_test.cpp -----------------------------------------------
 //
 // Testing the I/O facilities of tuples
@ -19,8 +27,6 @@
 #include <sstream>
 #endif
 #include "boost/config.hpp"
 using namespace std;
 using namespace boost;
@ -33,7 +39,12 @@ typedef istringstream useThisIStringStream;
 #endif
 int test_main(int argc, char * argv[] ) {
-
+   (void)argc;
   (void)argv;
   using boost::tuples::set_close;
   using boost::tuples::set_open;
   using boost::tuples::set_delimiter;
  useThisOStringStream os1;
  // Set format [a, b, c] for os1
@ -41,7 +52,7 @@ int test_main(int argc, char * argv[] ) {
  os1 << set_close(']');
  os1 << set_delimiter(',');
  os1 << make_tuple(1, 2, 3);
-  BOOST_TEST (os1.str() == std::string("[1,2,3]") );
+  BOOST_CHECK (os1.str() == std::string("[1,2,3]") );
  {
  useThisOStringStream os2;
@ -51,13 +62,13 @@ int test_main(int argc, char * argv[] ) {
  os2 << set_delimiter(':');
 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  os2 << make_tuple("TUPU", "HUPU", "LUPU", 4.5);
-  BOOST_TEST (os2.str() == std::string("(TUPU:HUPU:LUPU:4.5)") );
+  BOOST_CHECK (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]") );
+  BOOST_CHECK (os1.str() == std::string("[1,2,3][1,2,3]") );
  ofstream tmp("temp.tmp");
@ -71,17 +82,17 @@ int test_main(int argc, char * argv[] ) {
  // When teading tuples from a stream, manipulators must be set correctly:
  ifstream tmp3("temp.tmp");
-  tuple<string, string, int> j;		    
+  tuple<string, string, int> j;
 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  tmp3 >> j; 
-  BOOST_TEST (tmp3.good() ); 
+  BOOST_CHECK (tmp3.good() ); 
 #endif
  tmp3 >> set_delimiter(':');
  tuple<int, int, int> i;
  tmp3 >> i; 
-  BOOST_TEST (tmp3.good() ); 
+  BOOST_CHECK (tmp3.good() ); 
  tmp3.close(); 
@ -90,8 +101,8 @@ int test_main(int argc, char * argv[] ) {
  useThisIStringStream is("(100 200 300)"); 
  tuple<int, int, int> ti; 
-  BOOST_TEST(is >> ti);
+  BOOST_CHECK(bool(is >> ti));
-  BOOST_TEST(ti == make_tuple(100, 200, 300));
+  BOOST_CHECK(ti == make_tuple(100, 200, 300));
  // Note that strings are problematic:
--- a/test/tuple_test_bench.cpp
+++ b/test/tuple_test_bench.cpp
@ -1,7 +1,12 @@
-//  tuple_test_bench.cpp  --------------------------------
+// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
-// Defining any of E1 to E5 or E7 to E11 opens some illegal code that 
+// For more information, see http://www.boost.org
-// should cause the compliation to fail.
+
 //  tuple_test_bench.cpp  --------------------------------
 #define BOOST_INCLUDE_MAIN  // for testing, include rather than link
 #include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
@ -10,27 +15,68 @@
 #include "boost/tuple/tuple_comparison.hpp"
 #include "boost/type_traits/is_const.hpp"
 #include "boost/ref.hpp"
 #include <string>
 #include <utility>
 #include <vector>
 #include <algorithm>
 #include <functional>
 #include <iostream>
 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&) {}
-class A {}; class B {}; class C {};
+// 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 int(t)(float);
 // some arbitrary tuple definitions
 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;
@ -41,124 +87,231 @@ typedef tuple<volatile int, const volatile char&, int(&)(float) > t6;
 typedef tuple<B(A::*)(C&), A&> t7;
 #endif
-#endif
+// -----------------------------------------------------------------------
 // -tuple construction tests ---------------------------------------------
 // -----------------------------------------------------------------------
 // A non-copyable class
 class no_copy {
  no_copy(const no_copy&) {}
 public:
  no_copy() {};
 };
 no_copy y;
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 tuple<no_copy&> x = tuple<no_copy&>(y); // ok
 #endif
 #ifdef E1
 tuple<no_copy> v1;  // should faild
 #endif
 char cs[10];
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 tuple<char(&)[10]> v2(cs);  // ok
 #endif
 #ifdef E2
 tuple<char[10]> v3;  // should fail, arrays must be stored as references
 #endif
 void
 construction_test()
 {
-// -tuple construction tests ------------------------------------
+  // 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
-// a class without a public default constructor
+  tuple<int> t1;
-class no_def_constructor {
+  BOOST_CHECK(get<0>(t1) == int());
  no_def_constructor() {}
 public:
  no_def_constructor(std::string) {} // can be constructed with a string
  };
  tuple<float> t2(5.5f);
  BOOST_CHECK(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f);
-void foo1() {
+  tuple<foo> t3(foo(12));
  BOOST_CHECK(get<0>(t3) == foo(12));
-#ifdef E3
+  tuple<double> t4(t2);
-  dummy(tuple<no_def_constructor, no_def_constructor, no_def_constructor>()); 
+  BOOST_CHECK(get<0>(t4) > 5.4 && get<0>(t4) < 5.6);
  // should fail
-#endif
+  tuple<int, float> t5;
-  dummy( tuple<no_def_constructor, no_def_constructor, no_def_constructor>(
+  BOOST_CHECK(get<0>(t5) == int());
-                      std::string("Jaba"),   // ok, since the default 
+  BOOST_CHECK(get<1>(t5) == float());
-                      std::string("Daba"),   // constructor is not used
+
-                      std::string("Doo")));
+  tuple<int, float> t6(12, 5.5f);
-}
+  BOOST_CHECK(get<0>(t6) == 12);
  BOOST_CHECK(get<1>(t6) > 5.4f && get<1>(t6) < 5.6f);
  tuple<int, float> t7(t6);
  BOOST_CHECK(get<0>(t7) == 12);
  BOOST_CHECK(get<1>(t7) > 5.4f && get<1>(t7) < 5.6f);
  tuple<long, double> t8(t6);
  BOOST_CHECK(get<0>(t8) == 12);
  BOOST_CHECK(get<1>(t8) > 5.4f && get<1>(t8) < 5.6f);
  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")
    )
  );
 void foo2() {
 // testing default values
  dummy(tuple<int, double>());
  dummy(tuple<int, double>(1));
-  dummy(tuple<int, double>(1,3.14)); 
+  dummy(tuple<int, double>(1,3.14));
-#ifdef E4
+
-  dummy(tuple<double&>()); // should fail, not defaults for references
+  //  dummy(tuple<double&>()); // should fail, not defaults for references
-  dummy(tuple<const double&>()); // likewise
+  //  dummy(tuple<const double&>()); // likewise
 #endif
  double dd = 5;
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  dummy(tuple<double&>(dd)); // ok
 #endif
-#ifdef E5
+  dummy(tuple<const double&>(dd+3.14)); // ok, but dangerous
-  dummy(tuple<double&>(dd+3.14)); // should fail, temporary to non-const reference
+
-#endif
+  //  dummy(tuple<double&>(dd+3.14)); // should fail,
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+  //                                  // temporary to non-const reference
  dummy(tuple<const double&>(dd+3.14)); // ok, but potentially dangerous
 #endif
 }
 // ----------------------------------------------------------------------------
 // - testing element access ---------------------------------------------------
 // ----------------------------------------------------------------------------
-// make_tuple ------------------------------------------
+void element_access_test()
 {
  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);
-   void foo3() {
+  BOOST_CHECK(i == 1 && i2 == 2);
 #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));
+  int j  = get<0>(ct);
-#endif
+  BOOST_CHECK(j == 1);
  get<0>(t) = 5;
  BOOST_CHECK(t.head == 5);
  //  get<0>(ct) = 5; // can't assign to const
  double e = get<1>(t);
  BOOST_CHECK(e > 2.69 && e < 2.71);
  get<1>(t) = 3.14+i;
  BOOST_CHECK(get<1>(t) > 4.13 && get<1>(t) < 4.15);
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+  //  get<4>(t) = A(); // can't assign to const
  //  dummy(get<5>(ct)); // illegal index
  ++get<0>(t);
  BOOST_CHECK(get<0>(t) == 6);
  BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<0, tuple<int, float> >::type>::value != true));
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
  BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<0, const tuple<int, float> >::type>::value));
 #endif 
  BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<1, tuple<int, float> >::type>::value != true));
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
  BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<1, const tuple<int, float> >::type>::value));
 #endif 
  dummy(i); dummy(i2); dummy(j); dummy(e); // avoid warns for unused variables
 }
 // ----------------------------------------------------------------------------
 // - copying tuples -----------------------------------------------------------
 // ----------------------------------------------------------------------------
 void
 copy_test()
 {
  tuple<int, char> t1(4, 'a');
  tuple<int, char> t2(5, 'b');
  t2 = t1;
  BOOST_CHECK(get<0>(t1) == get<0>(t2));
  BOOST_CHECK(get<1>(t1) == get<1>(t2));
  tuple<long, std::string> t3(2, "a");
  t3 = t1;
  BOOST_CHECK((double)get<0>(t1) == get<0>(t3));
  BOOST_CHECK(get<1>(t1) == get<1>(t3)[0]);
 // 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_CHECK(i==1);
  BOOST_CHECK(c=='a');
  BOOST_CHECK(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_CHECK(get<0>(t1) == 6);
  BOOST_CHECK(get<1>(t1) > 2.1f && get<1>(t1) < 2.3f);
  BOOST_CHECK(get<2>(t1) == false);
  BOOST_CHECK(get<3>(t1) == foo(5));
 }
 // ----------------------------------------------------------------------------
 // make_tuple tests -----------------------------------------------------------
 // ----------------------------------------------------------------------------
 void
 make_tuple_test()
 {
  tuple<int, char> t1 = make_tuple(5, 'a');
  BOOST_CHECK(get<0>(t1) == 5);
  BOOST_CHECK(get<1>(t1) == 'a');
  tuple<int, std::string> t2;
  t2 = make_tuple((short int)2, std::string("Hi"));
  BOOST_CHECK(get<0>(t2) == 2);
  BOOST_CHECK(get<1>(t2) == "Hi");
    A a = A(); B b;
    const A ca = a;
    make_tuple(boost::cref(a), b);
    make_tuple(boost::ref(a), b);
    make_tuple(boost::ref(a), boost::cref(b));
    make_tuple(boost::ref(ca));
 // the result of make_tuple is assignable:
   BOOST_CHECK(make_tuple(2, 4, 6) == 
             (make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    make_tuple("Donald", "Daisy"); // should work;
-#endif
+#endif 
-#ifdef E7
+    //    std::make_pair("Doesn't","Work"); // fails
-    std::make_pair("Doesn't","Work"); // fails
+
 #endif
 // You can store a reference to a function in a tuple
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+    tuple<void(&)()> adf(make_tuple_test);
    tuple<void(&)()> adf(foo3);
    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(foo3);
+//   make_tuple(make_tuple_test);
 // With function pointers, make_tuple works just fine
 #if !defined(__BORLANDC__) || __BORLAND__ > 0x0551
-   make_tuple(&foo3);
+   make_tuple(&make_tuple_test);
 #endif
 // NOTE:
 //
 // wrapping it the function reference with ref helps on gcc 2.95.2.
@ -167,123 +320,158 @@ void foo2() {
 // make_tuple(ref(foo3));
 // It seems that edg can't use implicitly the ref's conversion operator, e.g.:
-// typedef void (&foo3type) (void);
+// typedef void (&func_t) (void);
-// foo3type foo3ref = static_cast<foo3type>(ref(foo3)); // works fine 
+// func_t fref = static_cast<func_t>(ref(make_tuple_test)); // works fine 
-// foo3type foo3ref = ref(foo3);                        // error
+// 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()
 // - testing element access
 void foo4() 
 {
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+  int a;
-  double d = 2.7; 
+  char b;
-  A a;
+  foo c(5);
  tuple<int, double&, const A&> t(1, d, a);
  const tuple<int, double&, const A> ct = t;
-  int i = get<0>(t);
+  tie(a, b, c) = make_tuple(2, 'a', foo(3));
-  int j = get<0>(ct);
+  BOOST_CHECK(a == 2);
-  BOOST_TEST(i == 1 && j == 1);
+  BOOST_CHECK(b == 'a');
-   
+  BOOST_CHECK(c == foo(3));
  get<0>(t) = 5;
  BOOST_TEST(t.head == 5);
 #ifdef E8
  get<0>(ct) = 5; // can't assign to const
 #endif
-  double e = get<1>(t);
+  tie(a, tuples::ignore, c) = make_tuple((short int)5, false, foo(5));
-  BOOST_TEST(e > 2.69 && e < 2.71);
+  BOOST_CHECK(a == 5);
-	     
+  BOOST_CHECK(b == 'a');
-  get<1>(t) = 3.14+i;
+  BOOST_CHECK(c == foo(5));
  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
 #ifdef E9
  get<4>(t) = A(); // can't assign to const
 #endif
 #ifdef E10
  dummy(get<5>(ct)); // illegal index
 #endif
  ++get<0>(t);
  BOOST_TEST(get<0>(t) == 6);
  dummy(i); dummy(j); dummy(e); // avoid warns for unused variables
 #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<int, AA*, CC, CC> a(t);
    a = t;
  }
  void foo6() {
    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.5);
  }
 // testing tie
 // testing assignment from std::pair
 void foo7() {
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   int i, j; 
   tie (i, j) = std::make_pair(1, 2);
-   BOOST_TEST(i == 1 && j == 2);
+   BOOST_CHECK(i == 1 && j == 2);
-#endif
+
-   tuple<int, int, float> a;
+   tuple<int, int, float> ta;
 #ifdef E11
-   a = std::make_pair(1, 2); // should fail, tuple is of length 3, not 2
+   ta = std::make_pair(1, 2); // should fail, tuple is of length 3, not 2
 #endif
-// the result of make_tuple is assignable:
+   dummy(ta);
   BOOST_TEST(make_tuple(2, 4, 6) == 
 	     (make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));
    dummy(a);
 }
-// Testing cons lists
+
-void foo8()
+// ----------------------------------------------------------------------------
 // - testing tuple equality   -------------------------------------------------
 // ----------------------------------------------------------------------------
 void
 equality_test()
 {
  tuple<int, char> t1(5, 'a');
  tuple<int, char> t2(5, 'a');
  BOOST_CHECK(t1 == t2);
  tuple<int, char> t3(5, 'b');
  tuple<int, char> t4(2, 'a');
  BOOST_CHECK(t1 != t3);
  BOOST_CHECK(t1 != t4);
  BOOST_CHECK(!(t1 != t2));
 }
 // ----------------------------------------------------------------------------
 // - 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_CHECK(t1 < t2);
  BOOST_CHECK(t1 <= t2);
  BOOST_CHECK(t2 > t1);
  BOOST_CHECK(t2 >= t1);
  BOOST_CHECK(t2 < t3);
  BOOST_CHECK(t2 <= t3);
  BOOST_CHECK(t3 > t2);
  BOOST_CHECK(t3 >= t2);
 }
 // ----------------------------------------------------------------------------
 // - testing cons lists -------------------------------------------------------
 // ----------------------------------------------------------------------------
 void cons_test()
 {
  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);
+  BOOST_CHECK(make_tuple(3,2,1)==c);
  cons<char, cons<int, cons<float, null_type> > > x;
  dummy(x);
 }
 // ----------------------------------------------------------------------------
 // - testing const tuples -----------------------------------------------------
 // ----------------------------------------------------------------------------
 void const_tuple_test()
 {
  const tuple<int, float> t1(5, 3.3f);
  BOOST_CHECK(get<0>(t1) == 5);
  BOOST_CHECK(get<1>(t1) == 3.3f);
 }
 // ----------------------------------------------------------------------------
 // - 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 *[]) {
-  foo1();
+  construction_test();
-  foo2();
+  element_access_test();
-  foo3();
+  copy_test();
-  foo4();
+  mutate_test();
-  foo5();
+  make_tuple_test();
-  foo6();
+  tie_test();
-  foo7();
+  equality_test();
-  foo8();
+  ordering_test();
-
+  cons_test();
  const_tuple_test();
  tuple_length_test();
  return 0;
 }
Author	SHA1	Message	Date
Ronald Garcia	2fb684b220	Created a branch from trunk [SVN r38959]	2007-08-26 05:34:35 +00:00
Vladimir Prus	d08c9bfab1	Update to V2 [SVN r38530]	2007-08-08 19:42:04 +00:00
Jaakko Järvi	19b8004830	Fixed a typo. [SVN r36896]	2007-02-06 00:23:26 +00:00
Daniel James	0af5b76442	Merge fixed links from RC_1_34_0. [SVN r36660]	2007-01-07 23:50:56 +00:00
Beman Dawes	defe1c94d6	Add copyright, license [SVN r35905]	2006-11-07 19:11:57 +00:00
Ralf W. Grosse-Kunstleve	76c2151830	avoid g++ -Wall -W "unused parameter" warnings [SVN r32373]	2006-01-22 19:29: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
Douglas Gregor	788896864a	Fixed a dumb typo (thanks Marsh) [SVN r14232]	2002-06-24 14:20:29 +00:00
Jaakko Järvi	d24e9b9a72	added a test for != [SVN r14091]	2002-06-06 15:47:23 +00:00
Jaakko Järvi	22d8e8ecc0	fixed != by suggestion of Björn Karlsson [SVN r14090]	2002-06-06 15:44:51 +00:00
Jaakko Järvi	08be3cbe04	removing tabs [SVN r13783]	2002-05-09 17:26:37 +00:00
Jaakko Järvi	b1621fad71	removed the demand for element types being copy constructible [SVN r13729]	2002-05-07 21:44:26 +00:00
Jaakko Järvi	001f5b4c14	Previous changes broke tuples for Borland, this should fix it [SVN r13611]	2002-05-01 20:53:44 +00:00
Jaakko Järvi	75d7917f66	- tuple types can now have void and plain function types as elements - tuple objects can hold non-copyable objects (such as arrays) [SVN r13525]	2002-04-19 19:32:19 +00:00
John Maddock	6d2cb1d793	Fixed VC7 compile problems (thanks to Sofus Mortensen). [SVN r13482]	2002-04-14 11:45:32 +00:00
John Maddock	ce02fa0c58	Removed crazy mess up from previous change: (the body of the test was commented out with #if 0) [SVN r12454]	2002-01-23 12:40:44 +00:00
Dave Abrahams	5f196d037f	added missing "inherited" typedef [SVN r12332]	2002-01-17 07:47:25 +00:00
John Maddock	2ab1b6705f	Changed occurances of "tuples::get" to "get" to verify new forwarding code in tuples.hpp [SVN r12291]	2002-01-13 12:12:48 +00:00
John Maddock	55a83b6408	Added forwarding get functions to solve problems with using::tuples::get statement. [SVN r12290]	2002-01-13 12:09:39 +00:00
Jaakko Järvi	c89357006b	reflecting the removal of src/tuple.cpp [SVN r12023]	2001-12-12 22:20:42 +00:00
Jaakko Järvi	2fe366f263	reflecting the change to remove tuple.cpp, adding some thanks [SVN r12022]	2001-12-12 22:17:09 +00:00
Jaakko Järvi	8b3b6efe24	not needed anymore [SVN r12021]	2001-12-12 22:08:12 +00:00
Jaakko Järvi	2e825630f8	made the iomanipulator storage indexes static members of a class. Now all code can be in header files. [SVN r12020]	2001-12-12 21:35:41 +00:00
Jaakko Järvi	8408cc0bd5	thomas witt:s patch for icl501, adds a workaround for explicitly qualified arguments Also fixed length, so that it now works for empty tuples as well [SVN r11722]	2001-11-16 23:27:08 +00:00
Jaakko Järvi	8f29dbe149	Thomas Witt's patch for icl501: adds better test coverage + tests for length template [SVN r11721]	2001-11-16 23:24:43 +00:00
Jaakko Järvi	e531e7ce2e	added a comment about performance penalties with some compilers [SVN r11603]	2001-11-05 21:18:48 +00:00
Jaakko Järvi	a6d8c4f20c	superseded by boost/ref.hpp [SVN r11275]	2001-09-26 13:23:31 +00:00
Peter Dimov	cd416f50be	Changed tuple.hpp to use ref.hpp [SVN r11274]	2001-09-26 12:27:43 +00:00
Darin Adler	9559531c52	Fixed unused variables that show up as warnings when doing regression tests. [SVN r11241]	2001-09-24 23:21:16 +00:00
Darin Adler	4503ed841b	Get rid of unused parameter to avoid warnings. [SVN r11214]	2001-09-22 19:36:44 +00:00
John Maddock	a9b6ca508a	Borland C++ fixes: typedef dependent types before using them. [SVN r11198]	2001-09-22 11:51:14 +00:00
Jaakko Järvi	063758ef7f	added full namespace qualifiers in get<N> calls to avoid errors in edg-strict mode [SVN r11133]	2001-09-17 10:32:32 +00:00
Jaakko Järvi	66ae617224	small change to avoid a warning for an unused variable [SVN r11132]	2001-09-17 10:31:44 +00:00
Jaakko Järvi	5b40ff62c6	merged tuples_subnamespace branch to main trunk [SVN r11121]	2001-09-14 07:55:58 +00:00
Jaakko Järvi	531fb617eb	Merged the tuples_subnamespace branch to main trunk. [SVN r11120]	2001-09-14 07:55:25 +00:00
Jaakko Järvi	2764718489	Reintroduced tuples subnamespace, documents now reflect that change [SVN r11119]	2001-09-14 07:54:33 +00:00
Douglas Gregor	e1bba349b3	tuple_basic_no_partial_spec.hpp: - Fixed cons construction for compilers with no partial specialization that aren't MSVC [SVN r11056]	2001-09-06 22:05:24 +00:00
Douglas Gregor	31efdb5485	Added support for assignment from std::pair. Test in tuple_test_bench.cpp enabled for MSVC version [SVN r11025]	2001-09-05 03:22:31 +00:00
Jaakko Järvi	d427f6027d	added documentation for default construction of cons lists [SVN r11017]	2001-09-04 10:59:20 +00:00
Jaakko Järvi	1c01745973	adding a test for cons list default construction [SVN r11016]	2001-09-04 10:50:13 +00:00
Jaakko Järvi	c789016905	included rich_cons [SVN r11015]	2001-09-04 10:44:37 +00:00
Jeremy Siek	5fb17f027f	SGI MIPSpro workaround in default_arg error checking [SVN r10998]	2001-09-03 15:42:55 +00:00
Douglas Gregor	b9cb417106	MSVC version of get<N> can now handle const tuples properly Testcase for const tuples added [SVN r10986]	2001-09-01 01:52:14 +00:00
Jaakko Järvi	3bbc493fc1	Corrected/refined the requirement for a tuple element type [SVN r10975]	2001-08-31 14:50:06 +00:00
Jaakko Järvi	23a2b7ba58	removed cons list construction tests if BOOST_NO_PARTIAL_SPECIALIZATION [SVN r10929]	2001-08-24 10:47:05 +00:00