This commit was manufactured by cvs2svn to create branch

'python-v2-dev'.

[SVN r14785]

doc/design_decisions_rationale.html

@@ -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
-sub-namespace' decision was taken, but it may be useful for other library writers.
-</p>
-<p>
-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. 
+The subnamespace name <i>tuples</i> raised some discussion.
+The rationale for not using the most natural name 'tuple' is to avoid having an identical name with the tuple template. 
+Namespace names are, however, not generally in plural form in boost libraries. 
+First, no real trouble was reported for using the same name for a namespace and a class and we considered changing the name 'tuples' to 'tuple'.
 But we found some trouble after all.
-One solution proposed to the dilemma of introducing a sub-namespace or not was as follows: use a
-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:
+Both gcc and edg compilers reject using declarations where the namespace and class names are 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 seemed to be ok: 
+Note, however, that a corresponding using declaration in the global namespace seems to be ok: 
 
 <code><pre>
 using boost::tuple::tuple; // ok;

doc/tuple_advanced_interface.html

@@ -12,17 +12,18 @@
   <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>.
 </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 +78,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 +92,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>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>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;::type</code> maps <code>T</code> to the return type of the non-const access functions (nonmeber and member <code>get</code> functions, and the <code>get_head</code> function).</li>
+<li><code>access_traits&lt;T&gt;::const_type</code> maps <code>T</code> to the return type of the const access functions.</li>
+<li><code>access_traits&lt;T&gt;::parameter_type</code> maps <code>T</code> to the parameter type of the tuple constructor.</li>
 </ol>
 <h4><code>make_tuple_traits</code></h4>
 
@@ -116,7 +121,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>

doc/tuple_users_guide.html

@@ -63,11 +63,10 @@ To compensate for this "deficiency", 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.:
-
-<ul>
-<li>classes that do not have a public copy constructor</li>
-<li>arrays</li>
-</ul>
-However, a reference to a non-copyable type is a valid element type.
+The data element can be any C++ type.
+Note that <code>void</code> and plain function types are valid 
+C++ types, but objects of such types cannot exist. 
+Hence, if a tuple type contains such types as elements, the tuple type
+can exist, but not an object of that type.
+There are natural limitations for element types that cannot
+be be copied, or that are not default constructible (see 'Constructing tuples'
+ below). 
 
 <p>
 For example, the following definitions are valid tuple instantiations (<code>A</code>, <code>B</code> and <code>C</code> are some user defined classes):
@@ -93,21 +93,6 @@ 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>
@@ -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>
 
@@ -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>
@@ -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. 
-Particularly, there is no performance difference between this code:
+All tuple access and construction functions are small inlined one-liners. 
+Therefore, a decent compiler can eliminate any extra cost of using tuples compared to using hand written tuple like classes. 
+Particularly, with a decent compiler there is no performance difference between this code:
 
 <pre><code>class hand_made_tuple { 
   A a; B b; C c;
@@ -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. 
@@ -474,11 +492,10 @@ 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. 
-The comments by Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes and David Abrahams helped to improve the
+Gary Powell has been an indispensable helping hand. In particular, stream manipulators for tuples were his idea. Doug Gregor came up with a working version for MSVC. Thanks to Jeremy Siek, William Kempf and Jens Maurer for their help and suggestions. 
+The comments by Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes, David Abrahams and Hartmut Kaiser helped to improve the
 library.
 The idea for the tie mechanism came from an old usenet article by Ian McCulloch, where he proposed something similar for std::pairs.
-
 <h2><a name = "references">References</a></h2>
 
 <p>
@@ -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 2001-09-13</p>
 
 <p>&copy; Copyright <a href="../../../people/jaakko_jarvi.htm"> Jaakko J&auml;rvi</a> 2001. 
 

include/boost/tuple/detail/tuple_basic.hpp

@@ -22,6 +22,16 @@
 // William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Davis,
 // David Abrahams.
 
+// Revision history:
+// 2002 05 01 Hugo Duncan: Fix for Borland after Jaakko's previous changes
+// 2002 04 18 Jaakko: tuple element types can be void or plain function 
+//                    types, as long as no object is created.
+//                    Tuple objects can no hold even noncopyable types
+//                    such as arrays.             
+// 2001 10 22 John Maddock
+//      Fixes for Borland C++
+// 2001 08 30 David Abrahams
+//      Added default constructor for cons<>.
 // ----------------------------------------------------------------- 
 
 #ifndef BOOST_TUPLE_BASIC_HPP
@@ -31,17 +41,28 @@
 #include <utility> // needed for the assignment from pair to tuple
 
 #include "boost/type_traits/cv_traits.hpp"
-							    
+#include "boost/type_traits/function_traits.hpp"
+    
 namespace boost {
+namespace tuples {
 
 // -- null_type --------------------------------------------------------
 struct null_type {};
 
 // a helper function to provide a const null_type type temporary
 namespace detail {
-namespace tuples {
-  inline const null_type cnull_type() { return null_type(); }
-} // end tuples
+  inline const null_type cnull() { return null_type(); }
+
+
+// -- if construct ------------------------------------------------
+// Proposed by Krzysztof Czarnecki and Ulrich Eisenecker
+
+template <bool If, class Then, class Else> struct IF { typedef Then RET; };
+
+template <class Then, class Else> struct IF<false, Then, Else> {
+  typedef Else RET;
+};
+
 } // end detail
 
 // - cons forward declaration -----------------------------------------------
@@ -57,55 +78,47 @@ template <
 class tuple; 
 
 // tuple_length forward declaration
-template<class T> struct tuple_length;
+template<class T> struct length;
 
 
 
 namespace detail {
-namespace tuples {
+
+#ifdef BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
+
+  template<int N> struct workaround_holder {};
+
+#  define BOOST_TUPLE_DUMMY_PARM        , detail::workaround_holder<N>* = 0
+#  define BOOST_TUPLE_SINGLE_DUMMY_PARM detail::workaround_holder<N>* = 0
+#else
+#  define BOOST_TUPLE_DUMMY_PARM
+#  define BOOST_TUPLE_SINGLE_DUMMY_PARM
+#endif
 
 // -- generate error template, referencing to non-existing members of this 
 // template is used to produce compilation errors intentionally
 template<class T>
 class generate_error;
 
-// tuple default argument wrappers ---------------------------------------
-// Work for non-reference types, intentionally not for references
-template <class T>
-struct default_arg {
-
-// Non-class temporaries cannot have qualifiers.
-// To prevent f to return for example const int, we remove cv-qualifiers
-// from all temporaries. 
-     static typename boost::remove_cv<T>::type f() { return T(); }
-};
-   
-template <class T>
-struct default_arg<T&> {
-  static T& f() { 
-    return generate_error<T>::no_default_values_for_reference_types;
-  }
-};
-
 // - cons getters --------------------------------------------------------
-// called: element<N>::get<RETURN_TYPE>(aTuple)
+// called: get_class<N>::get<RETURN_TYPE>(aTuple)
 
 template< int N >
-struct element {
+struct get_class {
   template<class RET, class HT, class TT >
   inline static RET get(const cons<HT, TT>& t)
   {
-    return element<N-1>::template get<RET>(t.tail);
+    return get_class<N-1>::template get<RET>(t.tail);
   }
   template<class RET, class HT, class TT >
   inline static RET get(cons<HT, TT>& t)
   {
-    return element<N-1>::template get<RET>(t.tail);
+    return get_class<N-1>::template get<RET>(t.tail);
   }
 };
 
 template<>
-struct element<0> {
+struct get_class<0> {
   template<class RET, class HT, class TT> 
   inline static RET get(const cons<HT, TT>& t)
   {
@@ -118,25 +131,24 @@ struct element<0> {
   }
 };
 
-} // end of namespace tuples
 } // end of namespace detail
 
 
 // -cons type accessors ----------------------------------------
-// typename tuple_element<N,T>::type gets the type of the 
+// typename tuples::element<N,T>::type gets the type of the 
 // Nth element ot T, first element is at index 0
 // -------------------------------------------------------
 
 template<int N, class T>
-struct tuple_element
+struct element
 {
 private:
   typedef typename T::tail_type Next;
 public:
-  typedef typename tuple_element<N-1, Next>::type type;
+  typedef typename element<N-1, Next>::type type;
 };
 template<class T>
-struct tuple_element<0,T>
+struct element<0,T>
 {
   typedef typename T::head_type type;
 };
@@ -150,11 +162,12 @@ struct tuple_element<0,T>
 // (Joel de Guzman's suggestion). Rationale: get functions are part of the
 // interface, so should the way to express their return types be.
 
-template <class T> struct tuple_access_traits {
+template <class T> struct access_traits {
   typedef const T& const_type;
   typedef T& non_const_type;
 
   typedef const typename boost::remove_cv<T>::type& parameter_type;
+
 // used as the tuple constructors parameter types
 // Rationale: non-reference tuple element types can be cv-qualified.
 // It should be possible to initialize such types with temporaries,
@@ -162,7 +175,7 @@ template <class T> struct tuple_access_traits {
 // be non-volatile and const. 8.5.3. (5)
 };
 
-template <class T> struct tuple_access_traits<T&> {
+template <class T> struct access_traits<T&> {
 
   typedef T& const_type;
   typedef T& non_const_type;
@@ -170,18 +183,17 @@ template <class T> struct tuple_access_traits<T&> {
   typedef T& parameter_type;   
 };
 
-
 // get function for non-const cons-lists, returns a reference to the element
 
 template<int N, class HT, class TT>
-inline typename tuple_access_traits<
-                  typename tuple_element<N, cons<HT, TT> >::type
+inline typename access_traits<
+                  typename element<N, cons<HT, TT> >::type
                 >::non_const_type
-get(cons<HT, TT>& c) { 
-  return detail::tuples::element<N>::template 
+get(cons<HT, TT>& c BOOST_TUPLE_DUMMY_PARM) { 
+  return detail::get_class<N>::template 
          get<
-           typename tuple_access_traits<
-             typename tuple_element<N, cons<HT, TT> >::type
+           typename access_traits<
+             typename element<N, cons<HT, TT> >::type
            >::non_const_type>(c); 
 } 
 
@@ -189,21 +201,40 @@ get(cons<HT, TT>& c) {
 // 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 tuple_access_traits<
-                  typename tuple_element<N, cons<HT, TT> >::type
+inline typename access_traits<
+                  typename element<N, cons<HT, TT> >::type
                 >::const_type
-get(const cons<HT, TT>& c) { 
-  return detail::tuples::element<N>::template 
+get(const cons<HT, TT>& c BOOST_TUPLE_DUMMY_PARM) { 
+  return detail::get_class<N>::template 
          get<
-           typename tuple_access_traits<
-             typename tuple_element<N, cons<HT, TT> >::type
+           typename access_traits<
+             typename element<N, cons<HT, TT> >::type
          >::const_type>(c);
 } 
 
-
-
-
 // -- the cons template  --------------------------------------------------
+namespace detail {
+
+//  These helper templates wrap void types and plain function types.
+//  The reationale is to allow one to write tuple types with those types
+//  as elements, even though it is not possible to instantiate such object.
+//  E.g: typedef tuple<void> some_type; // ok
+//  but: some_type x; // fails
+
+template <class T> class non_storeable_type {
+  non_storeable_type();
+};
+
+template <class T> struct wrap_non_storeable_type {
+  typedef typename IF<
+    ::boost::is_function<T>::value, non_storeable_type<T>, T
+  >::RET type;
+};
+template <> struct wrap_non_storeable_type<void> {
+  typedef non_storeable_type<void> type; 
+};
+
+} // detail
 
 template <class HT, class TT>
 struct cons {
@@ -211,22 +242,33 @@ struct cons {
   typedef HT head_type;
   typedef TT tail_type;
 
-  head_type head;
+  typedef typename 
+    detail::wrap_non_storeable_type<head_type>::type stored_head_type;
+
+  stored_head_type head;
   tail_type tail;
 
-  typename tuple_access_traits<head_type>::non_const_type 
+  typename access_traits<stored_head_type>::non_const_type 
   get_head() { return head; }
 
-  typename tuple_access_traits<tail_type>::non_const_type 
+  typename access_traits<tail_type>::non_const_type 
   get_tail() { return tail; }  
 
-  typename tuple_access_traits<head_type>::const_type 
+  typename access_traits<stored_head_type>::const_type 
   get_head() const { return head; }
   
-  typename tuple_access_traits<tail_type>::const_type 
+  typename access_traits<tail_type>::const_type 
   get_tail() const { return tail; }  
 
-  cons(typename tuple_access_traits<head_type>::parameter_type h,
+  cons() : head(), tail() {}
+  //  cons() : head(detail::default_arg<HT>::f()), tail() {}
+
+  // the argument for head is not strictly needed, but it prevents 
+  // array type elements. This is good, since array type elements 
+  // cannot be supported properly in any case (no assignment, 
+  // copy works only if the tails are exactly the same type, ...)
+  
+  cons(typename access_traits<stored_head_type>::parameter_type h,
        const tail_type& t)
     : head (h), tail(t) {}  
 
@@ -235,9 +277,18 @@ struct cons {
   cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, 
         T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 ) 
     : head (t1), 
-      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::tuples::cnull_type())
+      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
       {}
 
+  template <class T2, class T3, class T4, class T5, 
+            class T6, class T7, class T8, class T9, class T10>
+  cons( const null_type& t1, T2& t2, T3& t3, T4& t4, T5& t5, 
+        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 ) 
+    : head (), 
+      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
+      {}
+
+
   template <class HT2, class TT2>
   cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}
 
@@ -254,25 +305,25 @@ struct cons {
 
   template <class T1, class T2>
   cons& operator=( const std::pair<T1, T2>& u ) { 
-    BOOST_STATIC_ASSERT(tuple_length<cons>::value == 2); // check length = 2
+    BOOST_STATIC_ASSERT(length<cons>::value == 2); // check length = 2
     head = u.first; tail.head = u.second; return *this;
   }
 
   // get member functions (non-const and const)
   template <int N>
-  typename tuple_access_traits<
-             typename tuple_element<N, cons<HT, TT> >::type
+  typename access_traits<
+             typename element<N, cons<HT, TT> >::type
            >::non_const_type
   get() {
-    return boost::get<N>(*this); // delegate to non-member get
+    return boost::tuples::get<N>(*this); // delegate to non-member get
   }
 
   template <int N>
-  typename tuple_access_traits<
-             typename tuple_element<N, cons<HT, TT> >::type
+  typename access_traits<
+             typename element<N, cons<HT, TT> >::type
            >::const_type
   get() const {
-    return boost::get<N>(*this); // delegate to non-member get
+    return boost::tuples::get<N>(*this); // delegate to non-member get
   }
 };
 
@@ -282,19 +333,24 @@ struct cons<HT, null_type> {
   typedef HT head_type;
   typedef null_type tail_type;
 
-  head_type head;
+  typedef typename 
+    detail::wrap_non_storeable_type<head_type>::type stored_head_type;
+  stored_head_type head;
  
-  typename tuple_access_traits<head_type>::non_const_type 
+  typename access_traits<stored_head_type>::non_const_type 
   get_head() { return head; }
   
   null_type get_tail() { return null_type(); }  
 
-  typename tuple_access_traits<head_type>::const_type 
+  typename access_traits<stored_head_type>::const_type 
   get_head() const { return head; }
   
   const null_type get_tail() const { return null_type(); }  
-  
-  cons(typename tuple_access_traits<head_type>::parameter_type h,
+
+  //  cons() : head(detail::default_arg<HT>::f()) {}
+  cons() : head() {}
+
+  cons(typename access_traits<stored_head_type>::parameter_type h,
        const null_type& = null_type())
     : head (h) {}  
 
@@ -304,6 +360,12 @@ struct cons<HT, null_type> {
        const null_type&, const null_type&, const null_type&)
   : head (t1) {}
 
+  cons(const null_type& t1, 
+       const null_type&, const null_type&, const null_type&, 
+       const null_type&, const null_type&, const null_type&, 
+       const null_type&, const null_type&, const null_type&)
+  : head () {}
+
   template <class HT2>
   cons( const cons<HT2, null_type>& u ) : head(u.head) {}
   
@@ -316,19 +378,19 @@ struct cons<HT, null_type> {
   cons& operator=(const cons& u) { head = u.head; return *this; }
 
   template <int N>
-  typename tuple_access_traits<
-             typename tuple_element<N, cons>::type
+  typename access_traits<
+             typename element<N, cons>::type
             >::non_const_type
-  get() {
-    return boost::get<N>(*this);
+  get(BOOST_TUPLE_SINGLE_DUMMY_PARM) {
+    return boost::tuples::get<N>(*this);
   }
 
   template <int N>
-  typename tuple_access_traits<
-             typename tuple_element<N, cons>::type
+  typename access_traits<
+             typename element<N, cons>::type
            >::const_type
-  get() const {
-    return boost::get<N>(*this);
+  get(BOOST_TUPLE_SINGLE_DUMMY_PARM) const {
+    return boost::tuples::get<N>(*this);
   }
 
 };
@@ -336,18 +398,22 @@ struct cons<HT, null_type> {
 // templates for finding out the length of the tuple -------------------
 
 template<class T>
-struct tuple_length  {
-  BOOST_STATIC_CONSTANT(int, value = 1 + tuple_length<typename T::tail_type>::value);
+struct length  {
+  BOOST_STATIC_CONSTANT(int, value = 1 + length<typename T::tail_type>::value);
 };
 
 template<>
-struct tuple_length<null_type> {
+struct length<tuple<> > {
+  BOOST_STATIC_CONSTANT(int, value = 0);
+};
+
+template<>
+struct length<null_type> {
   BOOST_STATIC_CONSTANT(int, value = 0);
 };
 
 
 namespace detail {
-namespace tuples {
 
 // Tuple to cons mapper --------------------------------------------------
 template <class T0, class T1, class T2, class T3, class T4, 
@@ -367,7 +433,6 @@ struct map_tuple_to_cons<null_type, null_type, null_type, null_type, null_type,
   typedef null_type type;
 };
 
-} // end tuples
 } // end detail
 
 // -------------------------------------------------------------------
@@ -376,39 +441,105 @@ template <class T0, class T1, class T2, class T3, class T4,
           class T5, class T6, class T7, class T8, class T9>
 
 class tuple : 
-  public detail::tuples::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type   
+  public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type   
 {
 public:
   typedef typename 
-    detail::tuples::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited;
+    detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited;
   typedef typename inherited::head_type head_type;
   typedef typename inherited::tail_type tail_type;  
 
 
-// tuple_access_traits<T>::parameter_type takes non-reference types as const T& 
-  explicit tuple(
-    typename tuple_access_traits<T0>::parameter_type t0 
-      = detail::tuples::default_arg<T0>::f(),
-    typename tuple_access_traits<T1>::parameter_type t1 
-      = detail::tuples::default_arg<T1>::f(),
-    typename tuple_access_traits<T2>::parameter_type t2 
-      = detail::tuples::default_arg<T2>::f(),
-    typename tuple_access_traits<T3>::parameter_type t3 
-      = detail::tuples::default_arg<T3>::f(),
-    typename tuple_access_traits<T4>::parameter_type t4 
-      = detail::tuples::default_arg<T4>::f(),
-    typename tuple_access_traits<T5>::parameter_type t5 
-      = detail::tuples::default_arg<T5>::f(),
-    typename tuple_access_traits<T6>::parameter_type t6 
-      = detail::tuples::default_arg<T6>::f(),
-    typename tuple_access_traits<T7>::parameter_type t7 
-      = detail::tuples::default_arg<T7>::f(),
-    typename tuple_access_traits<T8>::parameter_type t8 
-      = detail::tuples::default_arg<T8>::f(),
-    typename tuple_access_traits<T9>::parameter_type t9 
-      = detail::tuples::default_arg<T9>::f())
+// access_traits<T>::parameter_type takes non-reference types as const T& 
+  tuple() {}
+  
+  tuple(typename access_traits<T0>::parameter_type t0)
+    : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(), 
+                detail::cnull(), detail::cnull(), detail::cnull(), 
+                detail::cnull(), detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1)
+    : inherited(t0, t1, detail::cnull(), detail::cnull(), 
+                detail::cnull(), detail::cnull(), detail::cnull(), 
+                detail::cnull(), detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2)
+    : inherited(t0, t1, t2, detail::cnull(), detail::cnull(), 
+                detail::cnull(), detail::cnull(), detail::cnull(), 
+                detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3)
+    : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(), 
+                detail::cnull(), detail::cnull(), detail::cnull(), 
+                detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4)
+    : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(), 
+                detail::cnull(), detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5)
+    : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(), 
+                detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(), 
+                detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6,
+        typename access_traits<T7>::parameter_type t7)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(), 
+                detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6,
+        typename access_traits<T7>::parameter_type t7,
+        typename access_traits<T8>::parameter_type t8)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6,
+        typename access_traits<T7>::parameter_type t7,
+        typename access_traits<T8>::parameter_type t8,
+        typename access_traits<T9>::parameter_type t9)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}
 
-        : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}
 
   template<class U1, class U2>
   tuple(const cons<U1, U2>& p) : inherited(p) {}
@@ -421,7 +552,7 @@ public:
 
   template <class U1, class U2>
   tuple& operator=(const std::pair<U1, U2>& k) { 
-    BOOST_STATIC_ASSERT(tuple_length<tuple>::value == 2);// check_length = 2
+    BOOST_STATIC_ASSERT(length<tuple>::value == 2);// check_length = 2
     this->head = k.first;
     this->tail.head = k.second; 
     return *this;
@@ -441,7 +572,6 @@ public:
 
 // Swallows any assignment   (by Doug Gregor)
 namespace detail {
-namespace tuples {
 
 struct swallow_assign {
       
@@ -450,12 +580,12 @@ struct swallow_assign {
     return *this;
   }
 };
-} // namespace tuples
+
 } // namespace detail
 
 // "ignore" allows tuple positions to be ignored when using "tie". 
 namespace {
- detail::tuples::swallow_assign ignore;
+ detail::swallow_assign ignore;
 }
 
 // ---------------------------------------------------------------------------
@@ -502,7 +632,7 @@ struct make_tuple_traits {
 template<class T>
 struct make_tuple_traits<T&> {
   typedef typename
-     detail::tuples::generate_error<T&>::
+     detail::generate_error<T&>::
        do_not_use_with_reference_type error;
 }; 
 
@@ -542,7 +672,6 @@ struct make_tuple_traits<const reference_wrapper<T> >{
 
 
 namespace detail {
-namespace tuples {
 
 // a helper traits to make the make_tuple functions shorter (Vesa Karvonen's
 // suggestion)
@@ -566,7 +695,6 @@ struct make_tuple_mapper {
           typename make_tuple_traits<T9>::type> type;
 };
 
-} // end tuples
 } // end detail
 
 // -make_tuple function templates -----------------------------------
@@ -575,87 +703,90 @@ inline tuple<> make_tuple() {
 }
 
 template<class T0>
-inline typename boost::detail::tuples::make_tuple_mapper<T0>::type
+inline typename detail::make_tuple_mapper<T0>::type
 make_tuple(const T0& t0) {
-  return typename boost::detail::tuples::make_tuple_mapper<T0>::type(t0); 
+  typedef typename detail::make_tuple_mapper<T0>::type t;
+  return t(t0);
 }
 
 template<class T0, class T1>
-inline typename boost::detail::tuples::make_tuple_mapper<T0, T1>::type
+inline typename detail::make_tuple_mapper<T0, T1>::type
 make_tuple(const T0& t0, const T1& t1) {
-  return typename boost::detail::tuples::make_tuple_mapper<T0, T1>::type(t0, t1); 
+  typedef typename detail::make_tuple_mapper<T0, T1>::type t;
+  return t(t0, t1);
 }
 
 template<class T0, class T1, class T2>
-inline typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2>::type
+inline typename detail::make_tuple_mapper<T0, T1, T2>::type
 make_tuple(const T0& t0, const T1& t1, const T2& t2) {
-  return typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2>::type(t0, t1, t2); 
+  typedef typename detail::make_tuple_mapper<T0, T1, T2>::type t;
+  return t(t0, t1, t2);
 }
 
 template<class T0, class T1, class T2, class T3>
-inline typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2, T3>::type
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3>::type
 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) {
-  return typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2, T3>::type
-           (t0, t1, t2, t3); 
+  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3>::type t;
+  return t(t0, t1, t2, t3);
 }
 
 template<class T0, class T1, class T2, class T3, class T4>
-inline typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2, T3, T4>::type
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type
 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                   const T4& t4) {
-  return typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2, T3, T4>::type
-           (t0, t1, t2, t3, t4); 
+  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type t;
+  return t(t0, t1, t2, t3, t4); 
 }
 
 template<class T0, class T1, class T2, class T3, class T4, class T5>
-inline typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                   const T4& t4, const T5& t5) {
-  return typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
-           (t0, t1, t2, t3, t4, t5); 
+  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type t;
+  return t(t0, t1, t2, t3, t4, t5); 
 }
 
 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
-inline typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::type
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::type
 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                   const T4& t4, const T5& t5, const T6& t6) {
-  return typename boost::detail::tuples::make_tuple_mapper
-           <T0, T1, T2, T3, T4, T5, T6>::type
-           (t0, t1, t2, t3, t4, t5, t6); 
+  typedef typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6);
 }
 
 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
          class T7>
-inline typename boost::detail::tuples::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                   const T4& t4, const T5& t5, const T6& t6, const T7& t7) {
-  return typename boost::detail::tuples::make_tuple_mapper
-           <T0, T1, T2, T3, T4, T5, T6, T7>::type
-           (t0, t1, t2, t3, t4, t5, t6, t7); 
+  typedef typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6, t7); 
 }
 
 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
          class T7, class T8>
-inline typename boost::detail::tuples::make_tuple_mapper
+inline typename detail::make_tuple_mapper
   <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                   const T4& t4, const T5& t5, const T6& t6, const T7& t7,
                   const T8& t8) {
-  return typename boost::detail::tuples::make_tuple_mapper
-           <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
-           (t0, t1, t2, t3, t4, t5, t6, t7, t8); 
+  typedef typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8); 
 }
 
 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
          class T7, class T8, class T9>
-inline typename boost::detail::tuples::make_tuple_mapper
+inline typename detail::make_tuple_mapper
   <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                   const T4& t4, const T5& t5, const T6& t6, const T7& t7,
                   const T8& t8, const T9& t9) {
-  return typename boost::detail::tuples::make_tuple_mapper
-           <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
-           (t0, t1, t2, t3, t4, t5, t6, t7, t8, t9); 
+  typedef typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9); 
 }
 
 
@@ -725,9 +856,12 @@ tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
            (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
 }
 
+} // end of namespace tuples
 } // end of namespace boost
 
+#undef BOOST_TUPLE_DUMMY_PARM
+#undef BOOST_TUPLE_SINGLE_DUMMY_PARM
 
-#endif	// BOOST_TUPLE_BASIC_HPP
+#endif // BOOST_TUPLE_BASIC_HPP
 
 

include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp

@@ -32,6 +32,7 @@
 #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,6 +41,7 @@
 #endif
 
 namespace boost {
+namespace tuples {
 
     // null_type denotes the end of a list built with "cons"
     struct null_type 
@@ -51,8 +53,23 @@ namespace boost {
     // a helper function to provide a const null_type type temporary
     inline const null_type cnull_type() { return null_type(); }
 
+// forward declaration of tuple
+    template<
+      typename T1 = null_type, 
+      typename T2 = null_type, 
+      typename T3 = null_type, 
+      typename T4 = null_type,
+      typename T5 = null_type,
+      typename T6 = null_type,
+      typename T7 = null_type,
+      typename T8 = null_type,
+      typename T9 = null_type,
+      typename T10 = null_type
+    >
+    class tuple;
+
     namespace detail {
-    namespace tuples {
+
       // Takes a pointer and routes all assignments to whatever it points to
       template<typename T>
       struct assign_to_pointee
@@ -81,38 +98,44 @@ namespace boost {
         }
       };
 
-  } // end of namespace tuples
   } // end of namespace detail
 
     // cons builds a heterogenous list of types
    template<typename Head, typename Tail = null_type>
-    struct cons
-    {
-      typedef cons self_type;
-      typedef Head head_type;
-      typedef Tail tail_type;
+   struct cons
+   {
+     typedef cons self_type;
+     typedef Head head_type;
+     typedef Tail tail_type;
 
-      head_type head;
-      tail_type tail;
+     head_type head;
+     tail_type tail;
 
-      typename boost::add_reference<head_type>::type get_head() { return head; }
-      typename boost::add_reference<tail_type>::type get_tail() { return tail; }  
+     typename boost::add_reference<head_type>::type get_head() { return head; }
+     typename boost::add_reference<tail_type>::type get_tail() { return tail; }  
 
-      typename boost::add_reference<const head_type>::type get_head() const { return head; }
-      typename boost::add_reference<const tail_type>::type get_tail() const { return tail; }
+     typename boost::add_reference<const head_type>::type get_head() const { return head; }
+     typename boost::add_reference<const tail_type>::type get_tail() const { return tail; }
   
-      template<typename Other>
-      explicit cons(const Other& other) : head(other.head), tail(other.tail)
+#if defined BOOST_MSVC
+      template<typename Tail>
+      explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
+                    const Tail& t) : head(h), tail(t.head, t.tail)
       {
       }
 
-#if defined BOOST_MSVC
       explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
-        const tail_type& t = tail_type()) :
-          head(h), tail(t)
+                    const null_type& t) : head(h), tail(t)
       {
       }
+
 #else
+      template<typename T>
+      explicit cons(const head_type& h, const T& t) : 
+        head(h), tail(t.head, t.tail)
+      {
+      }
+
       explicit cons(const head_type& h = head_type(),
                     const tail_type& t = tail_type()) :
         head(h), tail(t)
@@ -131,7 +154,7 @@ namespace boost {
     };
   
     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 }; };
@@ -168,16 +191,16 @@ namespace boost {
       >
       struct map_tuple_to_cons
       {
-        typedef typename detail::tuples::build_cons<T10, null_type  >::RET cons10;
-        typedef typename detail::tuples::build_cons<T9, cons10>::RET cons9;
-        typedef typename detail::tuples::build_cons<T8, cons9>::RET cons8;
-        typedef typename detail::tuples::build_cons<T7, cons8>::RET cons7;
-        typedef typename detail::tuples::build_cons<T6, cons7>::RET cons6;
-        typedef typename detail::tuples::build_cons<T5, cons6>::RET cons5;
-        typedef typename detail::tuples::build_cons<T4, cons5>::RET cons4;
-        typedef typename detail::tuples::build_cons<T3, cons4>::RET cons3;
-        typedef typename detail::tuples::build_cons<T2, cons3>::RET cons2;
-        typedef typename detail::tuples::build_cons<T1, cons2>::RET cons1;
+        typedef typename detail::build_cons<T10, null_type  >::RET cons10;
+        typedef typename detail::build_cons<T9, cons10>::RET cons9;
+        typedef typename detail::build_cons<T8, cons9>::RET cons8;
+        typedef typename detail::build_cons<T7, cons8>::RET cons7;
+        typedef typename detail::build_cons<T6, cons7>::RET cons6;
+        typedef typename detail::build_cons<T5, cons6>::RET cons5;
+        typedef typename detail::build_cons<T4, cons5>::RET cons4;
+        typedef typename detail::build_cons<T3, cons4>::RET cons3;
+        typedef typename detail::build_cons<T2, cons3>::RET cons2;
+        typedef typename detail::build_cons<T1, cons2>::RET cons1;
       };
 
       // Workaround the lack of partial specialization in some compilers
@@ -205,15 +228,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 +245,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 +312,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
-      get(Tuple& t)
+      typename detail::element_ref<N, cons<Head, Tail> >::RET
+      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
-      get(const Tuple& t)
+      typename detail::element_const_ref<N, cons<Head, Tail> >::RET
+      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
-      get(Tuple& t)
+      typename add_reference<Head>::type
+      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
-      get(const Tuple& t)
+      typename add_reference<const Head>::type
+      get(const cons<Head, Tail>& t)
       {
         return t.head;
       }
     };
 
+    } // namespace detail
+
     // tuple class
     template<
       typename T1, 
-      typename T2 = null_type, 
-      typename T3 = null_type, 
-      typename T4 = null_type,
-      typename T5 = null_type,
-      typename T6 = null_type,
-      typename T7 = null_type,
-      typename T8 = null_type,
-      typename T9 = null_type,
-      typename T10 = null_type
+      typename T2, 
+      typename T3, 
+      typename T4,
+      typename T5,
+      typename T6,
+      typename T7,
+      typename T8,
+      typename T9,
+      typename T10
     >
     class tuple : 
-      public detail::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;
@@ -331,6 +417,7 @@ namespace boost {
       typedef typename mapped_tuple::cons1 cons1;
 
     public:
+      typedef cons1 inherited;
       typedef tuple self_type;
 
       explicit tuple(const T1& t1 = T1(), 
@@ -347,36 +434,50 @@ namespace boost {
       {
       }
 
-      template<typename Other>
-      explicit tuple(const Other& other) : cons1(other)
+      template<typename Head, typename Tail>
+      explicit tuple(const cons<Head, Tail>& other) : 
+        cons1(other.head, other.tail)
       {
       }
 
-      template<typename Other>
-      self_type& operator=(const Other& other)
+      template<typename First, typename Second>
+      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
-    template<int N, typename Tuple>
-    typename detail::tuples::tuple_element_ref<N, Tuple>::RET
-    get(Tuple& t)
+    namespace detail {
+
+      template<int N> struct workaround_holder {};
+
+    } // 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 Tuple>
-    typename detail::tuples::tuple_element_const_ref<N, Tuple>::RET
-    get(const Tuple& t) 
+    template<int N, typename Head, typename Tail>
+    typename detail::element_const_ref<N, cons<Head, Tail> >::RET
+    get(const cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
     {
-      return element<N>::get(t);
+      return detail::get_class<N>::get(t);
     }
-     
+
     // Make a tuple
     template<typename T1>
     inline
@@ -470,185 +571,186 @@ 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>, 
-      detail::tuples::assign_to_pointee<T2> >
+    tuple<detail::assign_to_pointee<T1>, 
+      detail::assign_to_pointee<T2> >
     tie(T1& t1, T2& t2)
     {
-      return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
-                        detail::tuples::assign_to_pointee<T2>(&t2));
+      return make_tuple(detail::assign_to_pointee<T1>(&t1),
+                        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>, 
-      detail::tuples::assign_to_pointee<T2>, 
-      detail::tuples::assign_to_pointee<T3> >
+    tuple<detail::assign_to_pointee<T1>, 
+      detail::assign_to_pointee<T2>, 
+      detail::assign_to_pointee<T3> >
     tie(T1& t1, T2& t2, T3& t3)
     {
-      return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
-                        detail::tuples::assign_to_pointee<T2>(&t2),
-                        detail::tuples::assign_to_pointee<T3>(&t3));
+      return make_tuple(detail::assign_to_pointee<T1>(&t1),
+                        detail::assign_to_pointee<T2>(&t2),
+                        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>, 
-      detail::tuples::assign_to_pointee<T2>, 
-      detail::tuples::assign_to_pointee<T3>, 
-      detail::tuples::assign_to_pointee<T4> >
+    tuple<detail::assign_to_pointee<T1>, 
+      detail::assign_to_pointee<T2>, 
+      detail::assign_to_pointee<T3>, 
+      detail::assign_to_pointee<T4> >
     tie(T1& t1, T2& t2, T3& t3, T4& t4)
     {
-      return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
-                        detail::tuples::assign_to_pointee<T2>(&t2),
-                        detail::tuples::assign_to_pointee<T3>(&t3),
-                        detail::tuples::assign_to_pointee<T4>(&t4));
+      return make_tuple(detail::assign_to_pointee<T1>(&t1),
+                        detail::assign_to_pointee<T2>(&t2),
+                        detail::assign_to_pointee<T3>(&t3),
+                        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>, 
-      detail::tuples::assign_to_pointee<T2>, 
-      detail::tuples::assign_to_pointee<T3>, 
-      detail::tuples::assign_to_pointee<T4>, 
-      detail::tuples::assign_to_pointee<T5> >
+    tuple<detail::assign_to_pointee<T1>, 
+      detail::assign_to_pointee<T2>, 
+      detail::assign_to_pointee<T3>, 
+      detail::assign_to_pointee<T4>, 
+      detail::assign_to_pointee<T5> >
     tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5)
     {
-      return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
-                        detail::tuples::assign_to_pointee<T2>(&t2),
-                        detail::tuples::assign_to_pointee<T3>(&t3),
-                        detail::tuples::assign_to_pointee<T4>(&t4),
-                        detail::tuples::assign_to_pointee<T5>(&t5));
+      return make_tuple(detail::assign_to_pointee<T1>(&t1),
+                        detail::assign_to_pointee<T2>(&t2),
+                        detail::assign_to_pointee<T3>(&t3),
+                        detail::assign_to_pointee<T4>(&t4),
+                        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>, 
-      detail::tuples::assign_to_pointee<T2>, 
-      detail::tuples::assign_to_pointee<T3>, 
-      detail::tuples::assign_to_pointee<T4>, 
-      detail::tuples::assign_to_pointee<T5>, 
-      detail::tuples::assign_to_pointee<T6> >
+    tuple<detail::assign_to_pointee<T1>, 
+      detail::assign_to_pointee<T2>, 
+      detail::assign_to_pointee<T3>, 
+      detail::assign_to_pointee<T4>, 
+      detail::assign_to_pointee<T5>, 
+      detail::assign_to_pointee<T6> >
     tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6)
     {
-      return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
-                        detail::tuples::assign_to_pointee<T2>(&t2),
-                        detail::tuples::assign_to_pointee<T3>(&t3),
-                        detail::tuples::assign_to_pointee<T4>(&t4),
-                        detail::tuples::assign_to_pointee<T6>(&t5),
-                        detail::tuples::assign_to_pointee<T5>(&t6));
+      return make_tuple(detail::assign_to_pointee<T1>(&t1),
+                        detail::assign_to_pointee<T2>(&t2),
+                        detail::assign_to_pointee<T3>(&t3),
+                        detail::assign_to_pointee<T4>(&t4),
+                        detail::assign_to_pointee<T5>(&t5),
+                        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>, 
-      detail::tuples::assign_to_pointee<T2>, 
-      detail::tuples::assign_to_pointee<T3>, 
-      detail::tuples::assign_to_pointee<T4>, 
-      detail::tuples::assign_to_pointee<T5>, 
-      detail::tuples::assign_to_pointee<T6>, 
-      detail::tuples::assign_to_pointee<T7> >
+    tuple<detail::assign_to_pointee<T1>, 
+      detail::assign_to_pointee<T2>, 
+      detail::assign_to_pointee<T3>, 
+      detail::assign_to_pointee<T4>, 
+      detail::assign_to_pointee<T5>, 
+      detail::assign_to_pointee<T6>, 
+      detail::assign_to_pointee<T7> >
     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),
-                        detail::tuples::assign_to_pointee<T2>(&t2),
-                        detail::tuples::assign_to_pointee<T3>(&t3),
-                        detail::tuples::assign_to_pointee<T4>(&t4),
-                        detail::tuples::assign_to_pointee<T5>(&t5),
-                        detail::tuples::assign_to_pointee<T6>(&t6),
-                        detail::tuples::assign_to_pointee<T7>(&t7));
+      return make_tuple(detail::assign_to_pointee<T1>(&t1),
+                        detail::assign_to_pointee<T2>(&t2),
+                        detail::assign_to_pointee<T3>(&t3),
+                        detail::assign_to_pointee<T4>(&t4),
+                        detail::assign_to_pointee<T5>(&t5),
+                        detail::assign_to_pointee<T6>(&t6),
+                        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>, 
-      detail::tuples::assign_to_pointee<T2>, 
-      detail::tuples::assign_to_pointee<T3>, 
-      detail::tuples::assign_to_pointee<T4>, 
-      detail::tuples::assign_to_pointee<T5>, 
-      detail::tuples::assign_to_pointee<T6>, 
-      detail::tuples::assign_to_pointee<T7>, 
-      detail::tuples::assign_to_pointee<T8> >
+    tuple<detail::assign_to_pointee<T1>, 
+      detail::assign_to_pointee<T2>, 
+      detail::assign_to_pointee<T3>, 
+      detail::assign_to_pointee<T4>, 
+      detail::assign_to_pointee<T5>, 
+      detail::assign_to_pointee<T6>, 
+      detail::assign_to_pointee<T7>, 
+      detail::assign_to_pointee<T8> >
     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),
-                        detail::tuples::assign_to_pointee<T2>(&t2),
-                        detail::tuples::assign_to_pointee<T3>(&t3),
-                        detail::tuples::assign_to_pointee<T4>(&t4),
-                        detail::tuples::assign_to_pointee<T5>(&t5),
-                        detail::tuples::assign_to_pointee<T6>(&t6),
-                        detail::tuples::assign_to_pointee<T7>(&t7),
-                        detail::tuples::assign_to_pointee<T8>(&t8));
+      return make_tuple(detail::assign_to_pointee<T1>(&t1),
+                        detail::assign_to_pointee<T2>(&t2),
+                        detail::assign_to_pointee<T3>(&t3),
+                        detail::assign_to_pointee<T4>(&t4),
+                        detail::assign_to_pointee<T5>(&t5),
+                        detail::assign_to_pointee<T6>(&t6),
+                        detail::assign_to_pointee<T7>(&t7),
+                        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>, 
-      detail::tuples::assign_to_pointee<T2>, 
-      detail::tuples::assign_to_pointee<T3>, 
-      detail::tuples::assign_to_pointee<T4>, 
-      detail::tuples::assign_to_pointee<T5>, 
-      detail::tuples::assign_to_pointee<T6>, 
-      detail::tuples::assign_to_pointee<T7>, 
-      detail::tuples::assign_to_pointee<T8>, 
-      detail::tuples::assign_to_pointee<T9> >
+    tuple<detail::assign_to_pointee<T1>, 
+      detail::assign_to_pointee<T2>, 
+      detail::assign_to_pointee<T3>, 
+      detail::assign_to_pointee<T4>, 
+      detail::assign_to_pointee<T5>, 
+      detail::assign_to_pointee<T6>, 
+      detail::assign_to_pointee<T7>, 
+      detail::assign_to_pointee<T8>, 
+      detail::assign_to_pointee<T9> >
     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),
-                        detail::tuples::assign_to_pointee<T2>(&t2),
-                        detail::tuples::assign_to_pointee<T3>(&t3),
-                        detail::tuples::assign_to_pointee<T4>(&t4),
-                        detail::tuples::assign_to_pointee<T5>(&t5),
-                        detail::tuples::assign_to_pointee<T6>(&t6),
-                        detail::tuples::assign_to_pointee<T7>(&t7),
-                        detail::tuples::assign_to_pointee<T8>(&t8),
-                        detail::tuples::assign_to_pointee<T9>(&t9));
+      return make_tuple(detail::assign_to_pointee<T1>(&t1),
+                        detail::assign_to_pointee<T2>(&t2),
+                        detail::assign_to_pointee<T3>(&t3),
+                        detail::assign_to_pointee<T4>(&t4),
+                        detail::assign_to_pointee<T5>(&t5),
+                        detail::assign_to_pointee<T6>(&t6),
+                        detail::assign_to_pointee<T7>(&t7),
+                        detail::assign_to_pointee<T8>(&t8),
+                        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>, 
-      detail::tuples::assign_to_pointee<T2>, 
-      detail::tuples::assign_to_pointee<T3>, 
-      detail::tuples::assign_to_pointee<T4>, 
-      detail::tuples::assign_to_pointee<T5>, 
-      detail::tuples::assign_to_pointee<T6>, 
-      detail::tuples::assign_to_pointee<T7>, 
-      detail::tuples::assign_to_pointee<T8>, 
-      detail::tuples::assign_to_pointee<T9>, 
-      detail::tuples::assign_to_pointee<T10> >
+    tuple<detail::assign_to_pointee<T1>, 
+      detail::assign_to_pointee<T2>, 
+      detail::assign_to_pointee<T3>, 
+      detail::assign_to_pointee<T4>, 
+      detail::assign_to_pointee<T5>, 
+      detail::assign_to_pointee<T6>, 
+      detail::assign_to_pointee<T7>, 
+      detail::assign_to_pointee<T8>, 
+      detail::assign_to_pointee<T9>, 
+      detail::assign_to_pointee<T10> >
     tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9, T10 &t10)
     {
-      return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
-                        detail::tuples::assign_to_pointee<T2>(&t2),
-                        detail::tuples::assign_to_pointee<T3>(&t3),
-                        detail::tuples::assign_to_pointee<T4>(&t4),
-                        detail::tuples::assign_to_pointee<T5>(&t5),
-                        detail::tuples::assign_to_pointee<T6>(&t6),
-                        detail::tuples::assign_to_pointee<T7>(&t7),
-                        detail::tuples::assign_to_pointee<T8>(&t8),
-                        detail::tuples::assign_to_pointee<T9>(&t9),
-                        detail::tuples::assign_to_pointee<T10>(&t10));
+      return make_tuple(detail::assign_to_pointee<T1>(&t1),
+                        detail::assign_to_pointee<T2>(&t2),
+                        detail::assign_to_pointee<T3>(&t3),
+                        detail::assign_to_pointee<T4>(&t4),
+                        detail::assign_to_pointee<T5>(&t5),
+                        detail::assign_to_pointee<T6>(&t6),
+                        detail::assign_to_pointee<T7>(&t7),
+                        detail::assign_to_pointee<T8>(&t8),
+                        detail::assign_to_pointee<T9>(&t9),
+                        detail::assign_to_pointee<T10>(&t10));
     }
     // "ignore" allows tuple positions to be ignored when using "tie". 
     namespace {
-      detail::tuples::swallow_assign ignore;
+      detail::swallow_assign ignore;
     }
 
+} // namespace tuples
 } // namespace boost
 #endif // BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP

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

include/boost/tuple/tuple.hpp

@@ -27,10 +27,62 @@
 
 #else
 // other compilers
-#include "boost/tuple/reference_wrappers.hpp"
+#include "boost/ref.hpp"
 #include "boost/tuple/detail/tuple_basic.hpp"
 
 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
+namespace boost {    
 
-#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

include/boost/tuple/tuple_comparison.hpp

@@ -38,6 +38,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 +49,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 +69,7 @@ inline bool neq(const T1& lhs, const T2& rhs) {
          neq(lhs.get_tail(), rhs.get_tail());
 }
 template<>
-inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return true; }
+inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return false; }
 
 template<class T1, class T2>
 inline bool lt(const T1& lhs, const T2& rhs) {
@@ -107,7 +107,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 +115,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
-  BOOST_STATIC_ASSERT(tuple_length<T2>::value == tuple_length<S2>::value);
+  // check that tuple lengths are equal
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
 
-  return  detail::tuples::eq(lhs, rhs);
+  return  detail::eq(lhs, rhs);
 }
 
 // not equal -----
@@ -128,53 +127,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
-  BOOST_STATIC_ASSERT(tuple_length<T2>::value == tuple_length<S2>::value);
+  // check that tuple lengths are equal
+  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
-  BOOST_STATIC_ASSERT(tuple_length<T2>::value == tuple_length<S2>::value);
+  // check that tuple lengths are equal
+  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
-  BOOST_STATIC_ASSERT(tuple_length<T2>::value == tuple_length<S2>::value);
+  // check that tuple lengths are equal
+  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
-  BOOST_STATIC_ASSERT(tuple_length<T2>::value == tuple_length<S2>::value);
+  // check that tuple lengths are equal
+  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
-  BOOST_STATIC_ASSERT(tuple_length<T2>::value == tuple_length<S2>::value);
+  // check that tuple lengths are equal
+  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

include/boost/tuple/tuple_io.hpp

@@ -25,7 +25,7 @@
 #   if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97) 
 #define BOOST_NO_TEMPLATED_STREAMS
 #endif
-#endif	// __GNUC__
+#endif // __GNUC__
 
 #if defined BOOST_NO_TEMPLATED_STREAMS
 #include <iostream>
@@ -36,20 +36,26 @@
 
 #include "boost/tuple/tuple.hpp"
 
-
-				    
 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,13 +64,13 @@ public:
 
 #if defined (BOOST_NO_TEMPLATED_STREAMS)
    static char get_manipulator(std::ios& i, manipulator_type m) {
-     char c = static_cast<char>(i.iword(stream_index[m])); 
+     char c = static_cast<char>(i.iword(get_stream_index(m))); 
      
      // parentheses and space are the default manipulators
      if (!c) {
        switch(m) {
-         case open : c = '('; break;					    
-         case close : c = ')'; break;					    
+         case open : c = '('; break;
+         case close : c = ')'; break;
          case delimiter : c = ' '; break;
        }
      }
@@ -72,7 +78,7 @@ public:
    }
 
    static void set_manipulator(std::ios& i, manipulator_type m, char c) {
-      i.iword(stream_index[m]) = static_cast<long>(c);
+      i.iword(get_stream_index(m)) = static_cast<long>(c);
    }
 #else
    template<class CharType, class CharTrait>
@@ -82,12 +88,12 @@ public:
      // A valid instanitation of basic_stream allows CharType to be any POD,
      // hence, the static_cast may fail (it fails if long is not convertible 
      // to CharType
-     CharType c = static_cast<CharType>(i.iword(stream_index[m]) ); 
+     CharType c = static_cast<CharType>(i.iword(get_stream_index(m)) ); 
      // parentheses and space are the default manipulators
      if (!c) {
        switch(m) {
-         case open :  c = i.widen('('); break;					    
-         case close : c = i.widen(')'); break;					    
+         case open :  c = i.widen('('); break;
+         case close : c = i.widen(')'); break;
          case delimiter : c = i.widen(' '); break;
        }
      }
@@ -102,51 +108,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_TEMPLATED_STREAMS
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#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 +160,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 +175,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) {
-   return detail::tuples::tuple_manipulator<CharType>(detail::tuples::format_info::open, c);
+inline tuple_manipulator<CharType> set_open(const CharType c) {
+   return tuple_manipulator<CharType>(detail::format_info::open, c);
 }
 
 template<class CharType>
-inline detail::tuples::tuple_manipulator<CharType> set_close(const CharType c) {
-   return detail::tuples::tuple_manipulator<CharType>(detail::tuples::format_info::close, c);
+inline tuple_manipulator<CharType> set_close(const CharType c) {
+   return tuple_manipulator<CharType>(detail::format_info::close, c);
 }
 
 template<class CharType>
-inline detail::tuples::tuple_manipulator<CharType> set_delimiter(const CharType c) {
-   return detail::tuples::tuple_manipulator<CharType>(detail::tuples::format_info::delimiter, c);
+inline tuple_manipulator<CharType> set_delimiter(const CharType c) {
+   return tuple_manipulator<CharType>(detail::format_info::delimiter, c);
 }
 
 
@@ -194,7 +199,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 +210,7 @@ template<class T1>
 inline std::ostream& print(std::ostream& o, const cons<T1, null_type>& t) {
   return o << t.head;
 }
-#endif	// BOOST_NO_TEMPLATED_STREAMS
+#endif // BOOST_NO_TEMPLATED_STREAMS
  
 inline std::ostream& print(std::ostream& o, const null_type&) { return o; }
 
@@ -219,8 +223,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)
-	return o;
+  if (tuples::length<T2>::value == 0)
+    return o;
 #endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   o << d;
   
@@ -256,17 +260,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)
-	return o;
+  if (tuples::length<T2>::value == 0)
+    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 +278,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 +300,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)
 
@@ -353,7 +355,7 @@ read (std::istream &is, cons<T1, null_type>& t1) {
 }
 #else
 inline std::istream& read(std::istream& i, const null_type&) { return i; }
-#endif	// !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    
 template<class T1, class T2>
 inline std::istream& 
@@ -364,8 +366,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)
-	return is;
+  if (tuples::length<T2>::value == 0)
+    return is;
 #endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
   extract_and_check_delimiter(is, format_info::delimiter);
@@ -373,7 +375,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 +382,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::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::close);
+  detail::extract_and_check_delimiter(is, detail::format_info::open);
+  detail::extract_and_check_delimiter(is, detail::format_info::close);
 
   return is;
 }
@@ -394,11 +395,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;
 }
@@ -441,7 +442,7 @@ template<class CharType, class CharTrait>
 inline std::basic_istream<CharType, CharTrait>& 
 read(std::basic_istream<CharType, CharTrait>& i, const null_type&) { return i; }
 
-#endif	// !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 template<class CharType, class CharTrait, class T1, class T2>
 inline std::basic_istream<CharType, CharTrait>& 
@@ -452,8 +453,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)
-	return is;
+  if (tuples::length<T2>::value == 0)
+    return is;
 #endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
   extract_and_check_delimiter(is, format_info::delimiter);
@@ -461,7 +462,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 +471,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::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::close);
+  detail::extract_and_check_delimiter(is, detail::format_info::open);
+  detail::extract_and_check_delimiter(is, detail::format_info::close);
 
   return is;
 }
@@ -483,19 +483,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
 
 

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

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.

test/another_tuple_test_bench.cpp

@@ -1,5 +1,8 @@
-//  tuple_test_bench.cpp  --------------------------------
-//
+//  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 +11,147 @@
 
 #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) {}
-
-  bool operator==(const foo& other) const
-  {
-    return val == other.val;
-  }
-
-private:
-  foo() {}
-  int val;
+  no_copy() {};
 };
 
-void
-construction_test()
-{
-  tuple<int> t1; 
-  BOOST_TEST(get<0>(t1) == int());
-  
-  tuple<float> t2(5.5f);
-  BOOST_TEST(get<0>(t2) == 5.5f);
+no_copy y;
 
-  tuple<foo> t3(foo(12));
-  BOOST_TEST(get<0>(t3) == foo(12));
+#ifdef E1
+tuple<no_copy> v1;  // should faild
+#endif
 
-  tuple<double> t4(t2);
-  BOOST_TEST(get<0>(t4) == 5.5);
 
-  tuple<int, float> t5;
-  BOOST_TEST(get<0>(t5) == int());
-  BOOST_TEST(get<1>(t5) == float());
+#ifdef E2
+char cs[10];
+tuple<char[10]> v3;  // should fail, arrays must be stored as references
+#endif
 
-  tuple<int, float> t6(12, 5.5f);
-  BOOST_TEST(get<0>(t6) == 12);
-  BOOST_TEST(get<1>(t6) == 5.5f);
+// a class without a public default constructor
+class no_def_constructor {
+  no_def_constructor() {}
+public:
+  no_def_constructor(std::string) {} // can be constructed with a string
+};
 
-  tuple<long, double> t7(t6);
-  BOOST_TEST(get<0>(t7) == 12);
-  BOOST_TEST(get<1>(t7) == 5.5f);
+void foo1() {
+
+#ifdef E3
+  dummy(tuple<no_def_constructor, no_def_constructor, no_def_constructor>()); 
+  // should fail
+
+#endif
 }
 
-void
-copy_test()
-{
-  tuple<int, float> t1(4, 12.5f);
-  tuple<int, float> t2(5, 2.2f);
-  t2 = t1;
-  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);
+void foo2() {
+// testing default values
+#ifdef E4
+  dummy(tuple<double&>()); // should fail, not defaults for references
+  dummy(tuple<const double&>()); // likewise
+#endif
 
+#ifdef E5
+  double dd = 5;
+  dummy(tuple<double&>(dd+3.14)); // should fail, temporary to non-const reference
+#endif
 }
 
 
-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();
-  copy_test();
-  mutate_test();
-  make_tuple_test();
-  tie_test();
-  equality_test();
-  ordering_test();
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+  double d = 2.7; 
+  A a;
+  tuple<int, double&, const A&> t(1, d, a);
+  const tuple<int, double&, const A> ct = t;
+
+#ifdef E8
+  get<0>(ct) = 5; // can't assign to const
+#endif
+
+#ifdef E9
+  get<4>(t) = A(); // can't assign to const
+#endif
+#ifdef E10
+  dummy(get<5>(ct)); // illegal index
+#endif
+
+#endif
+}
+
+// testing copy and assignment with implicit conversions between elements
+// testing tie
+
+  class AA {};
+  class BB : public AA {};
+  struct CC { CC() {} CC(const BB& b) {} };
+  struct DD { operator CC() const { return CC(); }; };
+
+  void foo5() {
+    tuple<char, BB*, BB, DD> t;
+
+    tuple<char, char> aaa;
+    tuple<int, int> bbb(aaa);
+    //    tuple<int, AA*, CC, CC> a = t;
+    //    a = t;
+  }
+
+
+// testing tie
+// testing assignment from std::pair
+void foo7() {
+
+   tuple<int, int, float> a;
+#ifdef E11
+   a = std::make_pair(1, 2); // should fail, tuple is of length 3, not 2
+#endif
+
+    dummy(a);
+}
+
+
+
+// --------------------------------
+// ----------------------------
+int test_main(int, char *[]) {
+
+  foo1();
+  foo2();
+  foo3();
+  foo4();
+  foo5();
+
+  foo7();
 
   return 0;
 }

test/io_test.cpp

@@ -34,6 +34,10 @@ typedef istringstream useThisIStringStream;
 
 int test_main(int argc, char * argv[] ) {
 
+   using boost::tuples::set_close;
+   using boost::tuples::set_open;
+   using boost::tuples::set_delimiter;
+   
   useThisOStringStream os1;
 
   // Set format [a, b, c] for os1
@@ -71,7 +75,7 @@ int test_main(int argc, char * argv[] ) {
   
   // When teading tuples from a stream, manipulators must be set correctly:
   ifstream tmp3("temp.tmp");
-  tuple<string, string, int> j;		    
+  tuple<string, string, int> j;
 
 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   tmp3 >> j; 

test/tuple_test_bench.cpp

@@ -1,8 +1,5 @@
 //  tuple_test_bench.cpp  --------------------------------
 
-// Defining any of E1 to E5 or E7 to E11 opens some illegal code that 
-// should cause the compliation to fail.
-
 #define BOOST_INCLUDE_MAIN  // for testing, include rather than link
 #include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
 
@@ -12,24 +9,63 @@
 
 #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;
@@ -43,84 +79,223 @@ typedef tuple<B(A::*)(C&), A&> t7;
 
 #endif
 
-// A non-copyable class
-class no_copy {
-  no_copy(const no_copy&) {}
-public:
-  no_copy() {};
-};
+// -----------------------------------------------------------------------
+// -tuple construction tests ---------------------------------------------
+// -----------------------------------------------------------------------
 
-no_copy y;
 
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+no_copy y;
 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)
+char cs[10];
 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
-class no_def_constructor {
-  no_def_constructor() {}
-public:
-  no_def_constructor(std::string) {} // can be constructed with a string
-  };
+  tuple<int> t1;
+  BOOST_TEST(get<0>(t1) == int());
 
+  tuple<float> t2(5.5f);
+  BOOST_TEST(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f);
 
-void foo1() {
+  tuple<foo> t3(foo(12));
+  BOOST_TEST(get<0>(t3) == foo(12));
 
-#ifdef E3
-  dummy(tuple<no_def_constructor, no_def_constructor, no_def_constructor>()); 
-  // should fail
+  tuple<double> t4(t2);
+  BOOST_TEST(get<0>(t4) > 5.4 && get<0>(t4) < 5.6);
 
-#endif
-  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")));
-}
+  tuple<int, float> t5;
+  BOOST_TEST(get<0>(t5) == int());
+  BOOST_TEST(get<1>(t5) == float());
+
+  tuple<int, float> t6(12, 5.5f);
+  BOOST_TEST(get<0>(t6) == 12);
+  BOOST_TEST(get<1>(t6) > 5.4f && get<1>(t6) < 5.6f);
+
+  tuple<int, float> t7(t6);
+  BOOST_TEST(get<0>(t7) == 12);
+  BOOST_TEST(get<1>(t7) > 5.4f && get<1>(t7) < 5.6f);
+
+  tuple<long, double> t8(t6);
+  BOOST_TEST(get<0>(t8) == 12);
+  BOOST_TEST(get<1>(t8) > 5.4f && get<1>(t8) < 5.6f);
+
+  dummy(
+    tuple<no_def_constructor, no_def_constructor, no_def_constructor>(
+       std::string("Jaba"),   // ok, since the default
+       std::string("Daba"),   // constructor is not used
+       std::string("Doo")
+    )
+  );
 
-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<const double&>()); // likewise
-#endif
 
+  //  dummy(tuple<double&>()); // should fail, not defaults for references
+  //  dummy(tuple<const double&>()); // likewise
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   double dd = 5;
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   dummy(tuple<double&>(dd)); // ok
+
+  dummy(tuple<const double&>(dd+3.14)); // ok, but dangerous
 #endif
 
-#ifdef E5
-  dummy(tuple<double&>(dd+3.14)); // should fail, temporary to non-const reference
-#endif
+  //  dummy(tuple<double&>(dd+3.14)); // should fail,
+  //                                  // temporary to non-const reference
+}
+
+
+// ----------------------------------------------------------------------------
+// - testing element access ---------------------------------------------------
+// ----------------------------------------------------------------------------
+
+void element_access_test()
+{
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  dummy(tuple<const double&>(dd+3.14)); // ok, but potentially dangerous
+  double d = 2.7;
+  A a;
+  tuple<int, double&, const A&, int> t(1, d, a, 2);
+  const tuple<int, double&, const A, int> ct = t;
+
+  int i  = get<0>(t);
+  int i2 = get<3>(t);
+
+  BOOST_TEST(i == 1 && i2 == 2);
+
+  int j  = get<0>(ct);
+  BOOST_TEST(j == 1);
+   
+  get<0>(t) = 5;
+  BOOST_TEST(t.head == 5);
+   
+  //  get<0>(ct) = 5; // can't assign to const
+
+  double e = get<1>(t);
+  BOOST_TEST(e > 2.69 && e < 2.71);
+     
+  get<1>(t) = 3.14+i;
+  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
+
+  //  get<4>(t) = A(); // can't assign to const
+  //  dummy(get<5>(ct)); // illegal index
+
+  ++get<0>(t);
+  BOOST_TEST(get<0>(t) == 6);
+
+  dummy(i); dummy(i2); dummy(j); dummy(e); // avoid warns for unused variables
+#else
+  double d = 2.7; 
+  A a;
+  tuple<int, double, const A, int> t(1, d, a, 2);
+
+  int i  = get<0>(t);
+  int i2 = get<3>(t);
+
+  BOOST_TEST(i == 1 && i2 == 2);
+   
+  get<0>(t) = 5;
+  BOOST_TEST(t.head == 5);
+   
+  //  get<0>(ct) = 5; // can't assign to const
+
+  double e = get<1>(t);
+  BOOST_TEST(e > 2.69 && e < 2.71);
+     
+  get<1>(t) = 3.14+i;
+  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
+
+  //  get<4>(t) = A(); // can't assign to const
+  //  dummy(get<5>(ct)); // illegal index
+
+  ++get<0>(t);
+  BOOST_TEST(get<0>(t) == 6);
+
+  dummy(i); dummy(i2); dummy(e); // avoid warns for unused variables
 #endif
 }
 
 
-
-// make_tuple ------------------------------------------
+// ----------------------------------------------------------------------------
+// - copying tuples -----------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+
+
+void
+copy_test()
+{
+  tuple<int, char> t1(4, 'a');
+  tuple<int, char> t2(5, 'b');
+  t2 = t1;
+  BOOST_TEST(get<0>(t1) == get<0>(t2));
+  BOOST_TEST(get<1>(t1) == get<1>(t2));
+
+  tuple<long, std::string> t3(2, "a");
+  t3 = t1;
+  BOOST_TEST((double)get<0>(t1) == get<0>(t3));
+  BOOST_TEST(get<1>(t1) == get<1>(t3)[0]);
+
+// testing copy and assignment with implicit conversions between elements
+// testing tie
+
+  tuple<char, BB*, BB, DD> t;
+  tuple<int, AA*, CC, CC> a(t);
+  a = t;
+
+  int i; char c; double d;
+  tie(i, c, d) = make_tuple(1, 'a', 5.5);
+  
+  BOOST_TEST(i==1);
+  BOOST_TEST(c=='a');
+  BOOST_TEST(d>5.4 && d<5.6);
+}
+
+void
+mutate_test()
+{
+  tuple<int, float, bool, foo> t1(5, 12.2f, true, foo(4));
+  get<0>(t1) = 6;
+  get<1>(t1) = 2.2f;
+  get<2>(t1) = false;
+  get<3>(t1) = foo(5);
+
+  BOOST_TEST(get<0>(t1) == 6);
+  BOOST_TEST(get<1>(t1) > 2.1f && get<1>(t1) < 2.3f);
+  BOOST_TEST(get<2>(t1) == false);
+  BOOST_TEST(get<3>(t1) == foo(5));
+}
+
+// ----------------------------------------------------------------------------
+// make_tuple tests -----------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+void
+make_tuple_test()
+{
+  tuple<int, char> t1 = make_tuple(5, 'a');
+  BOOST_TEST(get<0>(t1) == 5);
+  BOOST_TEST(get<1>(t1) == 'a');
+
+  tuple<int, std::string> t2;
+  t2 = make_tuple((short int)2, std::string("Hi"));
+  BOOST_TEST(get<0>(t2) == 2);
+  BOOST_TEST(get<1>(t2) == "Hi");
 
 
-   void foo3() {
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
     A a; B b;
     const A ca = a;
@@ -131,16 +306,18 @@ void foo2() {
     make_tuple(ref(ca));
 #endif
      
+// the result of make_tuple is assignable:
+   BOOST_TEST(make_tuple(2, 4, 6) == 
+             (make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));
 
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
     make_tuple("Donald", "Daisy"); // should work;
 #endif
-#ifdef E7
-    std::make_pair("Doesn't","Work"); // fails
-#endif
+    //    std::make_pair("Doesn't","Work"); // fails
+
 // You can store a reference to a function in a tuple
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-    tuple<void(&)()> adf(foo3);
+    tuple<void(&)()> adf(make_tuple_test);
 
     dummy(adf); // avoid warning for unused variable
 #endif
@@ -148,17 +325,14 @@ void foo2() {
 // 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 +341,160 @@ 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);
-// foo3type foo3ref = static_cast<foo3type>(ref(foo3)); // works fine 
-// foo3type foo3ref = ref(foo3);                        // error
+// typedef void (&func_t) (void);
+// func_t fref = static_cast<func_t>(ref(make_tuple_test)); // works fine 
+// func_t fref = ref(make_tuple_test);                        // error
 
 // This is probably not a very common situation, so currently
 // I don't know how which compiler is right (JJ)
-      
 }
 
-
-
-// - testing element access
-
-void foo4() 
+void
+tie_test()
 {
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  double d = 2.7; 
-  A a;
-  tuple<int, double&, const A&> t(1, d, a);
-  const tuple<int, double&, const A> ct = t;
+  int a;
+  char b;
+  foo c(5);
 
-  int i = get<0>(t);
-  int j = get<0>(ct);
-  BOOST_TEST(i == 1 && j == 1);
-   
-  get<0>(t) = 5;
-  BOOST_TEST(t.head == 5);
-   
-#ifdef E8
-  get<0>(ct) = 5; // can't assign to const
-#endif
+  tie(a, b, c) = make_tuple(2, 'a', foo(3));
+  BOOST_TEST(a == 2);
+  BOOST_TEST(b == 'a');
+  BOOST_TEST(c == foo(3));
 
-  double e = get<1>(t);
-  BOOST_TEST(e > 2.69 && e < 2.71);
-	     
-  get<1>(t) = 3.14+i;
-  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
+  tie(a, tuples::ignore, c) = make_tuple((short int)5, false, foo(5));
+  BOOST_TEST(a == 5);
+  BOOST_TEST(b == 'a');
+  BOOST_TEST(c == foo(5));
 
-#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);
-#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:
-   BOOST_TEST(make_tuple(2, 4, 6) == 
-	     (make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));
-  
-    dummy(a);
+   dummy(ta);
 }
 
-// Testing cons lists
-void foo8()
+
+// ----------------------------------------------------------------------------
+// - testing tuple equality   -------------------------------------------------
+// ----------------------------------------------------------------------------
+
+void
+equality_test()
 {
+  tuple<int, char> t1(5, 'a');
+  tuple<int, char> t2(5, 'a');
+  BOOST_TEST(t1 == t2);
+
+  tuple<int, char> t3(5, 'b');
+  tuple<int, char> t4(2, 'a');
+  BOOST_TEST(t1 != t3);
+  BOOST_TEST(t1 != t4);
+  BOOST_TEST(!(t1 != t2));
+}
+
+
+// ----------------------------------------------------------------------------
+// - testing tuple comparisons  -----------------------------------------------
+// ----------------------------------------------------------------------------
+
+void
+ordering_test()
+{
+  tuple<int, float> t1(4, 3.3f);
+  tuple<short, float> t2(5, 3.3f);
+  tuple<long, double> t3(5, 4.4);
+  BOOST_TEST(t1 < t2);
+  BOOST_TEST(t1 <= t2);
+  BOOST_TEST(t2 > t1);
+  BOOST_TEST(t2 >= t1);
+  BOOST_TEST(t2 < t3);
+  BOOST_TEST(t2 <= t3);
+  BOOST_TEST(t3 > t2);
+  BOOST_TEST(t3 >= t2);
+
+}
+
+
+// ----------------------------------------------------------------------------
+// - testing cons lists -------------------------------------------------------
+// ----------------------------------------------------------------------------
+void cons_test()
+{
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+  using tuples::cons;
+  using tuples::null_type;
+
   cons<volatile float, null_type> a(1, null_type());
   cons<const int, cons<volatile float, null_type> > b(2,a);
   int i = 3;
   cons<int&, cons<const int, cons<volatile float, null_type> > > c(i, b);
   BOOST_TEST(make_tuple(3,2,1)==c);
+
+  cons<char, cons<int, cons<float, null_type> > > x;
+  dummy(x);
+#endif
+}
+
+// ----------------------------------------------------------------------------
+// - testing const tuples -----------------------------------------------------
+// ----------------------------------------------------------------------------
+void const_tuple_test()
+{
+  const tuple<int, float> t1(5, 3.3f);
+  BOOST_TEST(get<0>(t1) == 5);
+  BOOST_TEST(get<1>(t1) == 3.3f);
+}
+
+// ----------------------------------------------------------------------------
+// - testing length -----------------------------------------------------------
+// ----------------------------------------------------------------------------
+void tuple_length_test()
+{
+  typedef tuple<int, float, double> t1;
+  using tuples::cons;
+  typedef cons<int, cons< float, cons <double, tuples::null_type> > > t1_cons;
+  typedef tuple<> t2;
+  typedef tuples::null_type t3;  
+
+  BOOST_STATIC_ASSERT(tuples::length<t1>::value == 3);
+  BOOST_STATIC_ASSERT(tuples::length<t1_cons>::value == 3);
+  BOOST_STATIC_ASSERT(tuples::length<t2>::value == 0);
+  BOOST_STATIC_ASSERT(tuples::length<t3>::value == 0);
+
 }
 
 
-// --------------------------------
-// ----------------------------
+
+
+// ----------------------------------------------------------------------------
+// - main ---------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
 int test_main(int, char *[]) {
 
-  foo1();
-  foo2();
-  foo3();
-  foo4();
-  foo5();
-  foo6();
-  foo7();
-  foo8();
-
+  construction_test();
+  element_access_test();
+  copy_test();
+  mutate_test();
+  make_tuple_test();
+  tie_test();
+  equality_test();
+  ordering_test();
+  cons_test();
+  const_tuple_test();
+  tuple_length_test();
   return 0;
 }
+
+
+
+
+
+
+