Create a branch for documentation work.

[SVN r44584]

doc/tuple_advanced_interface.html

@@ -101,7 +101,7 @@ For a one-element cons list the tail argument (<code>null_type</code>) can be om
 <p>
 The template <code>access_traits</code> defines three type functions. Let <code>T</code> be a type of an element in a tuple:
 <ol>
-<li><code>access_traits&lt;T&gt;::type</code> maps <code>T</code> to the return type of the non-const access functions (nonmeber and member <code>get</code> functions, and the <code>get_head</code> function).</li>
+<li><code>access_traits&lt;T&gt;::non_const_type</code> maps <code>T</code> to the return type of the non-const access functions (nonmeber and member <code>get</code> functions, and the <code>get_head</code> function).</li>
 <li><code>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>

doc/tuple_users_guide.html

@@ -500,12 +500,12 @@ The idea for the tie mechanism came from an old usenet article by Ian McCulloch,
 
 <p>
 <a name="publ_1"></a>[1]
-J&auml;rvi J.: <i>Tuples and multiple return values in C++</i>, TUCS Technical Report No 249, 1999 (<a href="http://www.tucs.fi/Publications">http://www.tucs.fi/Publications</a>).
+J&auml;rvi J.: <i>Tuples and multiple return values in C++</i>, TUCS Technical Report No 249, 1999<!-- (<a href="http://www.tucs.fi/Publications">http://www.tucs.fi/Publications</a>)-->.
 </p>
 
 <p>
 <a name="publ_2"></a>[2]
-J&auml;rvi J.: <i>ML-Style Tuple Assignment in Standard C++ - Extending the Multiple Return Value Formalism</i>, TUCS Technical Report No 267, 1999 (<a href="http://www.tucs.fi/Publications">http://www.tucs.fi/Publications</a>).
+J&auml;rvi J.: <i>ML-Style Tuple Assignment in Standard C++ - Extending the Multiple Return Value Formalism</i>, TUCS Technical Report No 267, 1999<!-- (<a href="http://www.tucs.fi/Publications">http://www.tucs.fi/Publications</a>)-->.
 </p>
 
 <p>
@@ -516,7 +516,7 @@ J&auml;rvi J.: <i>ML-Style Tuple Assignment in Standard C++ - Extending the Mult
 
 <p>Last modified 2003-09-07</p>
 
-<p>&copy; Copyright <a href="../../../people/jaakko_jarvi.htm"> Jaakko J&auml;rvi</a> 2001. 
+<p>&copy; Copyright <a href="http://www.boost.org/people/jaakko_jarvi.htm"> Jaakko J&auml;rvi</a> 2001. 
 
 Permission to copy, use, modify, sell and distribute this software and its documentation is granted provided this copyright notice appears in all copies. 
 This software and its documentation is provided "as is" without express or implied warranty, and with no claim as to its suitability for any purpose.

include/boost/tuple/detail/tuple_basic.hpp

@@ -0,0 +1,944 @@
+//  tuple_basic.hpp -----------------------------------------------------
+
+// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+
+// Outside help:
+// This and that, Gary Powell.
+// Fixed return types for get_head/get_tail
+// ( and other bugs ) per suggestion of Jens Maurer
+// simplified element type accessors + bug fix  (Jeremy Siek)
+// Several changes/additions according to suggestions by Douglas Gregor,
+// William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes,
+// David Abrahams.
+
+// Revision history:
+// 2002 05 01 Hugo Duncan: Fix for Borland after Jaakko's previous changes
+// 2002 04 18 Jaakko: tuple element types can be void or plain function
+//                    types, as long as no object is created.
+//                    Tuple objects can no hold even noncopyable types
+//                    such as arrays.
+// 2001 10 22 John Maddock
+//      Fixes for Borland C++
+// 2001 08 30 David Abrahams
+//      Added default constructor for cons<>.
+// -----------------------------------------------------------------
+
+#ifndef BOOST_TUPLE_BASIC_HPP
+#define BOOST_TUPLE_BASIC_HPP
+
+
+#include <utility> // needed for the assignment from pair to tuple
+
+#include "boost/type_traits/cv_traits.hpp"
+#include "boost/type_traits/function_traits.hpp"
+
+#include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND
+
+namespace boost {
+namespace tuples {
+
+// -- null_type --------------------------------------------------------
+struct null_type {};
+
+// a helper function to provide a const null_type type temporary
+namespace detail {
+  inline const null_type cnull() { return null_type(); }
+
+
+// -- if construct ------------------------------------------------
+// Proposed by Krzysztof Czarnecki and Ulrich Eisenecker
+
+template <bool If, class Then, class Else> struct IF { typedef Then RET; };
+
+template <class Then, class Else> struct IF<false, Then, Else> {
+  typedef Else RET;
+};
+
+} // end detail
+
+// - cons forward declaration -----------------------------------------------
+template <class HT, class TT> struct cons;
+
+
+// - tuple forward declaration -----------------------------------------------
+template <
+  class T0 = null_type, class T1 = null_type, class T2 = null_type,
+  class T3 = null_type, class T4 = null_type, class T5 = null_type,
+  class T6 = null_type, class T7 = null_type, class T8 = null_type,
+  class T9 = null_type>
+class tuple;
+
+// tuple_length forward declaration
+template<class T> struct length;
+
+
+
+namespace detail {
+
+// -- generate error template, referencing to non-existing members of this
+// template is used to produce compilation errors intentionally
+template<class T>
+class generate_error;
+
+// - cons getters --------------------------------------------------------
+// called: get_class<N>::get<RETURN_TYPE>(aTuple)
+
+template< int N >
+struct get_class {
+  template<class RET, class HT, class TT >
+  inline static RET get(const cons<HT, TT>& t)
+  {
+#if BOOST_WORKAROUND(__IBMCPP__,==600)
+    // vacpp 6.0 is not very consistent regarding the member template keyword
+    // Here it generates an error when the template keyword is used.
+    return get_class<N-1>::get<RET>(t.tail);
+#else
+    return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
+#endif
+  }
+  template<class RET, class HT, class TT >
+  inline static RET get(cons<HT, TT>& t)
+  {
+#if BOOST_WORKAROUND(__IBMCPP__,==600)
+    return get_class<N-1>::get<RET>(t.tail);
+#else
+    return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
+#endif
+  }
+};
+
+template<>
+struct get_class<0> {
+  template<class RET, class HT, class TT>
+  inline static RET get(const cons<HT, TT>& t)
+  {
+    return t.head;
+  }
+  template<class RET, class HT, class TT>
+  inline static RET get(cons<HT, TT>& t)
+  {
+    return t.head;
+  }
+};
+
+} // end of namespace detail
+
+
+// -cons type accessors ----------------------------------------
+// typename tuples::element<N,T>::type gets the type of the
+// Nth element ot T, first element is at index 0
+// -------------------------------------------------------
+
+#ifndef BOOST_NO_CV_SPECIALIZATIONS
+
+template<int N, class T>
+struct element
+{
+private:
+  typedef typename T::tail_type Next;
+public:
+  typedef typename element<N-1, Next>::type type;
+};
+template<class T>
+struct element<0,T>
+{
+  typedef typename T::head_type type;
+};
+
+template<int N, class T>
+struct element<N, const T>
+{
+private:
+  typedef typename T::tail_type Next;
+  typedef typename element<N-1, Next>::type unqualified_type;
+public:
+#if BOOST_WORKAROUND(__BORLANDC__,<0x600)
+  typedef const unqualified_type type;
+#else
+  typedef typename boost::add_const<unqualified_type>::type type;
+#endif
+
+};
+template<class T>
+struct element<0,const T>
+{
+#if BOOST_WORKAROUND(__BORLANDC__,<0x600)
+  typedef const typename T::head_type type;
+#else
+  typedef typename boost::add_const<typename T::head_type>::type type;
+#endif
+};
+
+#else // def BOOST_NO_CV_SPECIALIZATIONS
+
+namespace detail {
+
+template<int N, class T, bool IsConst>
+struct element_impl
+{
+private:
+  typedef typename T::tail_type Next;
+public:
+  typedef typename element_impl<N-1, Next, IsConst>::type type;
+};
+
+template<int N, class T>
+struct element_impl<N, T, true /* IsConst */>
+{
+private:
+  typedef typename T::tail_type Next;
+public:
+  typedef const typename element_impl<N-1, Next, true>::type type;
+};
+
+template<class T>
+struct element_impl<0, T, false /* IsConst */>
+{
+  typedef typename T::head_type type;
+};
+
+template<class T>
+struct element_impl<0, T, true /* IsConst */>
+{
+  typedef const typename T::head_type type;
+};
+
+} // end of namespace detail
+
+
+template<int N, class T>
+struct element: 
+  public detail::element_impl<N, T, ::boost::is_const<T>::value>
+{
+};
+
+#endif
+
+
+// -get function templates -----------------------------------------------
+// Usage: get<N>(aTuple)
+
+// -- some traits classes for get functions
+
+// access traits lifted from detail namespace to be part of the interface,
+// (Joel de Guzman's suggestion). Rationale: get functions are part of the
+// interface, so should the way to express their return types be.
+
+template <class T> struct access_traits {
+  typedef const T& const_type;
+  typedef T& non_const_type;
+
+  typedef const typename boost::remove_cv<T>::type& parameter_type;
+
+// used as the tuple constructors parameter types
+// Rationale: non-reference tuple element types can be cv-qualified.
+// It should be possible to initialize such types with temporaries,
+// and when binding temporaries to references, the reference must
+// be non-volatile and const. 8.5.3. (5)
+};
+
+template <class T> struct access_traits<T&> {
+
+  typedef T& const_type;
+  typedef T& non_const_type;
+
+  typedef T& parameter_type;
+};
+
+// get function for non-const cons-lists, returns a reference to the element
+
+template<int N, class HT, class TT>
+inline typename access_traits<
+                  typename element<N, cons<HT, TT> >::type
+                >::non_const_type
+get(cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+#if BOOST_WORKAROUND(__IBMCPP__,==600 )
+  return detail::get_class<N>::
+#else
+  return detail::get_class<N>::BOOST_NESTED_TEMPLATE
+#endif
+         get<
+           typename access_traits<
+             typename element<N, cons<HT, TT> >::type
+           >::non_const_type,
+           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 access_traits<
+                  typename element<N, cons<HT, TT> >::type
+                >::const_type
+get(const cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+#if BOOST_WORKAROUND(__IBMCPP__,==600)
+  return detail::get_class<N>::
+#else
+  return detail::get_class<N>::BOOST_NESTED_TEMPLATE
+#endif
+         get<
+           typename access_traits<
+             typename element<N, cons<HT, TT> >::type
+           >::const_type,
+           HT,TT
+         >(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 {
+
+  typedef HT head_type;
+  typedef TT tail_type;
+
+  typedef typename
+    detail::wrap_non_storeable_type<head_type>::type stored_head_type;
+
+  stored_head_type head;
+  tail_type tail;
+
+  typename access_traits<stored_head_type>::non_const_type
+  get_head() { return head; }
+
+  typename access_traits<tail_type>::non_const_type
+  get_tail() { return tail; }
+
+  typename access_traits<stored_head_type>::const_type
+  get_head() const { return head; }
+
+  typename access_traits<tail_type>::const_type
+  get_tail() const { return tail; }
+
+  cons() : head(), tail() {}
+  //  cons() : head(detail::default_arg<HT>::f()), tail() {}
+
+  // the argument for head is not strictly needed, but it prevents
+  // array type elements. This is good, since array type elements
+  // cannot be supported properly in any case (no assignment,
+  // copy works only if the tails are exactly the same type, ...)
+
+  cons(typename access_traits<stored_head_type>::parameter_type h,
+       const tail_type& t)
+    : head (h), tail(t) {}
+
+  template <class T1, class T2, class T3, class T4, class T5,
+            class T6, class T7, class T8, class T9, class T10>
+  cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5,
+        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
+    : head (t1),
+      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
+      {}
+
+  template <class T2, class T3, class T4, class T5,
+            class T6, class T7, class T8, class T9, class T10>
+  cons( const null_type& /*t1*/, T2& t2, T3& t3, T4& t4, T5& t5,
+        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
+    : head (),
+      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
+      {}
+
+
+  template <class HT2, class TT2>
+  cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}
+
+  template <class HT2, class TT2>
+  cons& operator=( const cons<HT2, TT2>& u ) {
+    head=u.head; tail=u.tail; return *this;
+  }
+
+  // must define assignment operator explicitly, implicit version is
+  // illformed if HT is a reference (12.8. (12))
+  cons& operator=(const cons& u) {
+    head = u.head; tail = u.tail;  return *this;
+  }
+
+  template <class T1, class T2>
+  cons& operator=( const std::pair<T1, T2>& u ) {
+    BOOST_STATIC_ASSERT(length<cons>::value == 2); // check length = 2
+    head = u.first; tail.head = u.second; return *this;
+  }
+
+  // get member functions (non-const and const)
+  template <int N>
+  typename access_traits<
+             typename element<N, cons<HT, TT> >::type
+           >::non_const_type
+  get() {
+    return boost::tuples::get<N>(*this); // delegate to non-member get
+  }
+
+  template <int N>
+  typename access_traits<
+             typename element<N, cons<HT, TT> >::type
+           >::const_type
+  get() const {
+    return boost::tuples::get<N>(*this); // delegate to non-member get
+  }
+};
+
+template <class HT>
+struct cons<HT, null_type> {
+
+  typedef HT head_type;
+  typedef null_type tail_type;
+  typedef cons<HT, null_type> self_type;
+
+  typedef typename
+    detail::wrap_non_storeable_type<head_type>::type stored_head_type;
+  stored_head_type head;
+
+  typename access_traits<stored_head_type>::non_const_type
+  get_head() { return head; }
+
+  null_type get_tail() { return null_type(); }
+
+  typename access_traits<stored_head_type>::const_type
+  get_head() const { return head; }
+
+  const null_type get_tail() const { return null_type(); }
+
+  //  cons() : head(detail::default_arg<HT>::f()) {}
+  cons() : head() {}
+
+  cons(typename access_traits<stored_head_type>::parameter_type h,
+       const null_type& = null_type())
+    : head (h) {}
+
+  template<class T1>
+  cons(T1& t1, const null_type&, const null_type&, const null_type&,
+       const null_type&, const null_type&, const null_type&,
+       const null_type&, const null_type&, const null_type&)
+  : head (t1) {}
+
+  cons(const null_type&,
+       const null_type&, const null_type&, const null_type&,
+       const null_type&, const null_type&, const null_type&,
+       const null_type&, const null_type&, const null_type&)
+  : head () {}
+
+  template <class HT2>
+  cons( const cons<HT2, null_type>& u ) : head(u.head) {}
+
+  template <class HT2>
+  cons& operator=(const cons<HT2, null_type>& u )
+  { head = u.head; return *this; }
+
+  // must define assignment operator explicitely, implicit version
+  // is illformed if HT is a reference
+  cons& operator=(const cons& u) { head = u.head; return *this; }
+
+  template <int N>
+  typename access_traits<
+             typename element<N, self_type>::type
+            >::non_const_type
+  get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+    return boost::tuples::get<N>(*this);
+  }
+
+  template <int N>
+  typename access_traits<
+             typename element<N, self_type>::type
+           >::const_type
+  get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) const {
+    return boost::tuples::get<N>(*this);
+  }
+
+};
+
+// templates for finding out the length of the tuple -------------------
+
+template<class T>
+struct length  {
+  BOOST_STATIC_CONSTANT(int, value = 1 + length<typename T::tail_type>::value);
+};
+
+template<>
+struct length<tuple<> > {
+  BOOST_STATIC_CONSTANT(int, value = 0);
+};
+
+template<>
+struct length<null_type> {
+  BOOST_STATIC_CONSTANT(int, value = 0);
+};
+
+
+namespace detail {
+
+// Tuple to cons mapper --------------------------------------------------
+template <class T0, class T1, class T2, class T3, class T4,
+          class T5, class T6, class T7, class T8, class T9>
+struct map_tuple_to_cons
+{
+  typedef cons<T0,
+               typename map_tuple_to_cons<T1, T2, T3, T4, T5,
+                                          T6, T7, T8, T9, null_type>::type
+              > type;
+};
+
+// The empty tuple is a null_type
+template <>
+struct map_tuple_to_cons<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>
+{
+  typedef null_type type;
+};
+
+} // end detail
+
+// -------------------------------------------------------------------
+// -- tuple ------------------------------------------------------
+template <class T0, class T1, class T2, class T3, class T4,
+          class T5, class T6, class T7, class T8, class T9>
+
+class tuple :
+  public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
+{
+public:
+  typedef typename
+    detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited;
+  typedef typename inherited::head_type head_type;
+  typedef typename inherited::tail_type tail_type;
+
+
+// access_traits<T>::parameter_type takes non-reference types as const T&
+  tuple() {}
+
+  tuple(typename access_traits<T0>::parameter_type t0)
+    : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1)
+    : inherited(t0, t1, detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2)
+    : inherited(t0, t1, t2, detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3)
+    : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull(),
+                detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4)
+    : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5)
+    : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(),
+                detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6,
+        typename access_traits<T7>::parameter_type t7)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(),
+                detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6,
+        typename access_traits<T7>::parameter_type t7,
+        typename access_traits<T8>::parameter_type t8)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6,
+        typename access_traits<T7>::parameter_type t7,
+        typename access_traits<T8>::parameter_type t8,
+        typename access_traits<T9>::parameter_type t9)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}
+
+
+  template<class U1, class U2>
+  tuple(const cons<U1, U2>& p) : inherited(p) {}
+
+  template <class U1, class U2>
+  tuple& operator=(const cons<U1, U2>& k) {
+    inherited::operator=(k);
+    return *this;
+  }
+
+  template <class U1, class U2>
+  tuple& operator=(const std::pair<U1, U2>& k) {
+    BOOST_STATIC_ASSERT(length<tuple>::value == 2);// check_length = 2
+    this->head = k.first;
+    this->tail.head = k.second;
+    return *this;
+  }
+
+};
+
+// The empty tuple
+template <>
+class tuple<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>  :
+  public null_type
+{
+public:
+  typedef null_type inherited;
+};
+
+
+// Swallows any assignment   (by Doug Gregor)
+namespace detail {
+
+struct swallow_assign {
+
+  template<typename T>
+  swallow_assign const& operator=(const T&) const {
+    return *this;
+  }
+};
+
+} // namespace detail
+
+// "ignore" allows tuple positions to be ignored when using "tie".
+detail::swallow_assign const ignore = detail::swallow_assign();
+
+// ---------------------------------------------------------------------------
+// The call_traits for make_tuple
+// Honours the reference_wrapper class.
+
+// Must be instantiated with plain or const plain types (not with references)
+
+// from template<class T> foo(const T& t) : make_tuple_traits<const T>::type
+// from template<class T> foo(T& t) : make_tuple_traits<T>::type
+
+// Conversions:
+// T -> T,
+// references -> compile_time_error
+// reference_wrapper<T> -> T&
+// const reference_wrapper<T> -> T&
+// array -> const ref array
+
+
+template<class T>
+struct make_tuple_traits {
+  typedef T type;
+
+  // commented away, see below  (JJ)
+  //  typedef typename IF<
+  //  boost::is_function<T>::value,
+  //  T&,
+  //  T>::RET type;
+
+};
+
+// The is_function test was there originally for plain function types,
+// which can't be stored as such (we must either store them as references or
+// pointers). Such a type could be formed if make_tuple was called with a
+// reference to a function.
+// But this would mean that a const qualified function type was formed in
+// the make_tuple function and hence make_tuple can't take a function
+// reference as a parameter, and thus T can't be a function type.
+// So is_function test was removed.
+// (14.8.3. says that type deduction fails if a cv-qualified function type
+// is created. (It only applies for the case of explicitly specifying template
+// args, though?)) (JJ)
+
+template<class T>
+struct make_tuple_traits<T&> {
+  typedef typename
+     detail::generate_error<T&>::
+       do_not_use_with_reference_type error;
+};
+
+// Arrays can't be stored as plain types; convert them to references.
+// All arrays are converted to const. This is because make_tuple takes its
+// parameters as const T& and thus the knowledge of the potential
+// non-constness of actual argument is lost.
+template<class T, int n>  struct make_tuple_traits <T[n]> {
+  typedef const T (&type)[n];
+};
+
+template<class T, int n>
+struct make_tuple_traits<const T[n]> {
+  typedef const T (&type)[n];
+};
+
+template<class T, int n>  struct make_tuple_traits<volatile T[n]> {
+  typedef const volatile T (&type)[n];
+};
+
+template<class T, int n>
+struct make_tuple_traits<const volatile T[n]> {
+  typedef const volatile T (&type)[n];
+};
+
+template<class T>
+struct make_tuple_traits<reference_wrapper<T> >{
+  typedef T& type;
+};
+
+template<class T>
+struct make_tuple_traits<const reference_wrapper<T> >{
+  typedef T& type;
+};
+
+
+
+
+namespace detail {
+
+// a helper traits to make the make_tuple functions shorter (Vesa Karvonen's
+// suggestion)
+template <
+  class T0 = null_type, class T1 = null_type, class T2 = null_type,
+  class T3 = null_type, class T4 = null_type, class T5 = null_type,
+  class T6 = null_type, class T7 = null_type, class T8 = null_type,
+  class T9 = null_type
+>
+struct make_tuple_mapper {
+  typedef
+    tuple<typename make_tuple_traits<T0>::type,
+          typename make_tuple_traits<T1>::type,
+          typename make_tuple_traits<T2>::type,
+          typename make_tuple_traits<T3>::type,
+          typename make_tuple_traits<T4>::type,
+          typename make_tuple_traits<T5>::type,
+          typename make_tuple_traits<T6>::type,
+          typename make_tuple_traits<T7>::type,
+          typename make_tuple_traits<T8>::type,
+          typename make_tuple_traits<T9>::type> type;
+};
+
+} // end detail
+
+// -make_tuple function templates -----------------------------------
+inline tuple<> make_tuple() {
+  return tuple<>();
+}
+
+template<class T0>
+inline typename detail::make_tuple_mapper<T0>::type
+make_tuple(const T0& t0) {
+  typedef typename detail::make_tuple_mapper<T0>::type t;
+  return t(t0);
+}
+
+template<class T0, class T1>
+inline typename detail::make_tuple_mapper<T0, T1>::type
+make_tuple(const T0& t0, const T1& t1) {
+  typedef typename detail::make_tuple_mapper<T0, T1>::type t;
+  return t(t0, t1);
+}
+
+template<class T0, class T1, class T2>
+inline typename detail::make_tuple_mapper<T0, T1, T2>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2) {
+  typedef typename detail::make_tuple_mapper<T0, T1, T2>::type t;
+  return t(t0, t1, t2);
+}
+
+template<class T0, class T1, class T2, class T3>
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) {
+  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3>::type t;
+  return t(t0, t1, t2, t3);
+}
+
+template<class T0, class T1, class T2, class T3, class T4>
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
+                  const T4& t4) {
+  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type t;
+  return t(t0, t1, t2, t3, t4);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5>
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
+                  const T4& t4, const T5& t5) {
+  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type t;
+  return t(t0, t1, t2, t3, t4, t5);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
+                  const T4& t4, const T5& t5, const T6& t6) {
+  typedef typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+         class T7>
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
+                  const T4& t4, const T5& t5, const T6& t6, const T7& t7) {
+  typedef typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6, t7);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+         class T7, class T8>
+inline typename detail::make_tuple_mapper
+  <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
+                  const T4& t4, const T5& t5, const T6& t6, const T7& t7,
+                  const T8& t8) {
+  typedef typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+         class T7, class T8, class T9>
+inline typename detail::make_tuple_mapper
+  <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
+                  const T4& t4, const T5& t5, const T6& t6, const T7& t7,
+                  const T8& t8, const T9& t9) {
+  typedef typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
+}
+
+
+
+// Tie function templates -------------------------------------------------
+template<class T1>
+inline tuple<T1&> tie(T1& t1) {
+  return tuple<T1&> (t1);
+}
+
+template<class T1, class T2>
+inline tuple<T1&, T2&> tie(T1& t1, T2& t2) {
+  return tuple<T1&, T2&> (t1, t2);
+}
+
+template<class T1, class T2, class T3>
+inline tuple<T1&, T2&, T3&> tie(T1& t1, T2& t2, T3& t3) {
+  return tuple<T1&, T2&, T3&> (t1, t2, t3);
+}
+
+template<class T1, class T2, class T3, class T4>
+inline tuple<T1&, T2&, T3&, T4&> tie(T1& t1, T2& t2, T3& t3, T4& t4) {
+  return tuple<T1&, T2&, T3&, T4&> (t1, t2, t3, t4);
+}
+
+template<class T1, class T2, class T3, class T4, class T5>
+inline tuple<T1&, T2&, T3&, T4&, T5&>
+tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) {
+  return tuple<T1&, T2&, T3&, T4&, T5&> (t1, t2, t3, t4, t5);
+}
+
+template<class T1, class T2, class T3, class T4, class T5, class T6>
+inline tuple<T1&, T2&, T3&, T4&, T5&, T6&>
+tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) {
+  return tuple<T1&, T2&, T3&, T4&, T5&, T6&> (t1, t2, t3, t4, t5, t6);
+}
+
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
+inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&>
+tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) {
+  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> (t1, t2, t3, t4, t5, t6, t7);
+}
+
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
+         class T8>
+inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
+tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) {
+  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
+           (t1, t2, t3, t4, t5, t6, t7, t8);
+}
+
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
+         class T8, class T9>
+inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
+tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
+           T9& t9) {
+  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
+            (t1, t2, t3, t4, t5, t6, t7, t8, t9);
+}
+
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
+         class T8, class T9, class T10>
+inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
+tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
+           T9& t9, T10& t10) {
+  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
+           (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
+}
+
+} // end of namespace tuples
+} // end of namespace boost
+
+
+#endif // BOOST_TUPLE_BASIC_HPP
+
+

include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp

@@ -0,0 +1,841 @@
+// - tuple_basic_no_partial_spec.hpp -----------------------------------------
+
+// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2001 Douglas Gregor (gregod@rpi.edu)
+// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org or http://lambda.cs.utu.fi
+
+// Revision History
+//  14 02 01    Remove extra ';'. Also, fixed 10-parameter to make_tuple. (DG)
+//  10 02 01    Fixed "null_type" constructors.
+//              Implemented comparison operators globally.
+//              Hide element_type_ref and element_type_const_ref.
+//              (DG).
+//  09 02 01    Extended to tuples of length 10. Changed comparison for
+//              operator<()
+//              to the same used by std::pair<>, added cnull_type() (GP)
+//  03 02 01    Initial Version from original tuple.hpp code by JJ. (DG)
+
+// -----------------------------------------------------------------
+
+#ifndef BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
+#define BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
+
+#include "boost/type_traits.hpp"
+#include <utility>
+
+#if defined BOOST_MSVC
+#pragma warning(disable:4518) // storage-class or type specifier(s) unexpected here; ignored
+#pragma warning(disable:4181) // qualifier applied to reference type ignored
+#pragma warning(disable:4227) // qualifier applied to reference type ignored
+#endif
+
+namespace boost {
+namespace tuples {
+
+    // null_type denotes the end of a list built with "cons"
+    struct null_type
+    {
+      null_type() {}
+      null_type(const null_type&, const null_type&) {}
+    };
+
+    // a helper function to provide a const null_type type temporary
+    inline const null_type cnull_type() { return null_type(); }
+
+// forward declaration of tuple
+    template<
+      typename T1 = null_type,
+      typename T2 = null_type,
+      typename T3 = null_type,
+      typename T4 = null_type,
+      typename T5 = null_type,
+      typename T6 = null_type,
+      typename T7 = null_type,
+      typename T8 = null_type,
+      typename T9 = null_type,
+      typename T10 = null_type
+    >
+    class tuple;
+
+// forward declaration of cons
+    template<typename Head, typename Tail = null_type>
+    struct cons;
+
+    namespace detail {
+
+      // Takes a pointer and routes all assignments to whatever it points to
+      template<typename T>
+      struct assign_to_pointee
+      {
+      public:
+        explicit assign_to_pointee(T* p) : ptr(p) {}
+
+        template<typename Other>
+        assign_to_pointee& operator=(const Other& other)
+        {
+          *ptr = other;
+          return *this;
+        }
+
+      private:
+        T* ptr;
+      };
+
+      // Swallows any assignment
+      struct swallow_assign
+      {
+        template<typename T>
+        swallow_assign const& operator=(const T&) const
+        {
+          return *this;
+        }
+      };
+
+    template <typename T> struct add_const_reference : add_reference<typename add_const<T>::type> {};
+
+    template <class MyTail>
+    struct init_tail
+    {
+        // Each of vc6 and vc7 seem to require a different formulation
+        // of this return type
+        template <class H, class T>
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+        static typename add_reference<typename add_const<T>::type>::type
+#else
+        static typename add_const_reference<T>::type
+#endif
+        execute( cons<H,T> const& u, long )
+        {
+            return u.get_tail();
+        }
+    };
+
+    template <>
+    struct init_tail<null_type>
+    {
+        template <class H>
+        static null_type execute( cons<H,null_type> const& u, long )
+        {
+            return null_type();
+        }
+
+        template <class U>
+        static null_type execute(U const&, ...)
+        {
+            return null_type();
+        }
+     private:
+        template <class H, class T>
+        void execute( cons<H,T> const&, int);
+    };
+
+    template <class Other>
+    Other const&
+    init_head( Other const& u, ... )
+    {
+        return u;
+    }
+
+    template <class H, class T>
+    typename add_reference<typename add_const<H>::type>::type
+    init_head( cons<H,T> const& u, int )
+    {
+        return u.get_head();
+    }
+
+    inline char**** init_head(null_type const&, int);
+
+  } // end of namespace detail
+
+    // cons builds a heterogenous list of types
+   template<typename Head, typename Tail>
+   struct cons
+   {
+     typedef cons self_type;
+     typedef Head head_type;
+     typedef Tail tail_type;
+
+    private:
+       typedef typename boost::add_reference<head_type>::type head_ref;
+       typedef typename boost::add_reference<tail_type>::type tail_ref;
+       typedef typename detail::add_const_reference<head_type>::type head_cref;
+       typedef typename detail::add_const_reference<tail_type>::type tail_cref;
+    public:
+     head_type head;
+     tail_type tail;
+
+     head_ref get_head() { return head; }
+     tail_ref get_tail() { return tail; }
+
+     head_cref get_head() const { return head; }
+     tail_cref get_tail() const { return tail; }
+
+     cons() : head(), tail() {}
+
+#if defined BOOST_MSVC
+      template<typename Tail>
+      cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
+                    const Tail& t) : head(h), tail(t.head, t.tail)
+      {
+      }
+
+      cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
+                    const null_type& t) : head(h), tail(t)
+      {
+      }
+
+#else
+      template<typename T>
+      explicit cons(head_cref h, const T& t) :
+        head(h), tail(t.head, t.tail)
+      {
+      }
+
+      explicit cons(head_cref h = head_type(),
+                    tail_cref t = tail_type()) :
+        head(h), tail(t)
+      {
+      }
+#endif
+
+      template <class U>
+      cons( const U& u )
+        : head(detail::init_head(u, 0))
+        , tail(detail::init_tail<Tail>::execute(u, 0L))
+       {
+       }
+
+      template<typename Other>
+      cons& operator=(const Other& other)
+      {
+        head = other.head;
+        tail = other.tail;
+        return *this;
+      }
+    };
+
+    namespace detail {
+
+      // Determines if the parameter is null_type
+      template<typename T> struct is_null_type { enum { RET = 0 }; };
+      template<> struct is_null_type<null_type> { enum { RET = 1 }; };
+
+      /* Build a cons structure from the given Head and Tail. If both are null_type,
+      return null_type. */
+      template<typename Head, typename Tail>
+      struct build_cons
+      {
+      private:
+        enum { tail_is_null_type = is_null_type<Tail>::RET };
+      public:
+        typedef cons<Head, Tail> RET;
+      };
+
+      template<>
+      struct build_cons<null_type, null_type>
+      {
+        typedef null_type RET;
+      };
+
+      // Map the N elements of a tuple into a cons list
+      template<
+        typename T1,
+        typename T2 = null_type,
+        typename T3 = null_type,
+        typename T4 = null_type,
+        typename T5 = null_type,
+        typename T6 = null_type,
+        typename T7 = null_type,
+        typename T8 = null_type,
+        typename T9 = null_type,
+        typename T10 = null_type
+      >
+      struct map_tuple_to_cons
+      {
+        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
+      template<int N>
+      struct _element_type
+      {
+        template<typename Tuple>
+        struct inner
+        {
+        private:
+          typedef typename Tuple::tail_type tail_type;
+          typedef _element_type<N-1> next_elt_type;
+
+        public:
+          typedef typename _element_type<N-1>::template inner<tail_type>::RET RET;
+        };
+      };
+
+      template<>
+      struct _element_type<0>
+      {
+        template<typename Tuple>
+        struct inner
+        {
+          typedef typename Tuple::head_type RET;
+        };
+      };
+
+    } // namespace detail
+
+
+    // Return the Nth type of the given Tuple
+    template<int N, typename Tuple>
+    struct element
+    {
+    private:
+      typedef detail::_element_type<N> nth_type;
+
+    public:
+      typedef typename nth_type::template inner<Tuple>::RET RET;
+      typedef RET type;
+    };
+
+    namespace detail {
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
+      // special workaround for vc7:
+
+      template <bool x>
+      struct reference_adder
+      {
+         template <class T>
+         struct rebind
+         {
+            typedef T& type;
+         };
+      };
+
+      template <>
+      struct reference_adder<true>
+      {
+         template <class T>
+         struct rebind
+         {
+            typedef T type;
+         };
+      };
+
+
+      // Return a reference to the Nth type of the given Tuple
+      template<int N, typename Tuple>
+      struct element_ref
+      {
+      private:
+         typedef typename element<N, Tuple>::RET elt_type;
+         enum { is_ref = is_reference<elt_type>::value };
+
+      public:
+         typedef reference_adder<is_ref>::rebind<elt_type>::type RET;
+         typedef RET type;
+      };
+
+      // Return a const reference to the Nth type of the given Tuple
+      template<int N, typename Tuple>
+      struct element_const_ref
+      {
+      private:
+         typedef typename element<N, Tuple>::RET elt_type;
+         enum { is_ref = is_reference<elt_type>::value };
+
+      public:
+         typedef reference_adder<is_ref>::rebind<const elt_type>::type RET;
+         typedef RET type;
+      };
+
+#else // vc7
+
+      // Return a reference to the Nth type of the given Tuple
+      template<int N, typename Tuple>
+      struct element_ref
+      {
+      private:
+        typedef typename element<N, Tuple>::RET elt_type;
+
+      public:
+        typedef typename add_reference<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;
+
+      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 length
+    {
+      BOOST_STATIC_CONSTANT(int, value = 1 + length<typename Tuple::tail_type>::value);
+    };
+
+    template<> struct length<tuple<> > {
+      BOOST_STATIC_CONSTANT(int, value = 0);
+    };
+
+    template<>
+    struct length<null_type>
+    {
+      BOOST_STATIC_CONSTANT(int, value = 0);
+    };
+
+    namespace detail {
+
+    // Reference the Nth element in a tuple and retrieve it with "get"
+    template<int N>
+    struct get_class
+    {
+      template<typename Head, typename Tail>
+      static inline
+      typename detail::element_ref<N, cons<Head, Tail> >::RET
+      get(cons<Head, Tail>& t)
+      {
+        return get_class<N-1>::get(t.tail);
+      }
+
+      template<typename Head, typename Tail>
+      static inline
+      typename detail::element_const_ref<N, cons<Head, Tail> >::RET
+      get(const cons<Head, Tail>& t)
+      {
+        return get_class<N-1>::get(t.tail);
+      }
+    };
+
+    template<>
+    struct get_class<0>
+    {
+      template<typename Head, typename Tail>
+      static inline
+      typename add_reference<Head>::type
+      get(cons<Head, Tail>& t)
+      {
+        return t.head;
+      }
+
+      template<typename Head, typename Tail>
+      static inline
+      typename add_reference<const Head>::type
+      get(const cons<Head, Tail>& t)
+      {
+        return t.head;
+      }
+    };
+
+    } // namespace detail
+
+    // tuple class
+    template<
+      typename T1,
+      typename T2,
+      typename T3,
+      typename T4,
+      typename T5,
+      typename T6,
+      typename T7,
+      typename T8,
+      typename T9,
+      typename T10
+    >
+    class tuple :
+      public detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
+    {
+    private:
+      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;
+      typedef typename mapped_tuple::cons7 cons7;
+      typedef typename mapped_tuple::cons6 cons6;
+      typedef typename mapped_tuple::cons5 cons5;
+      typedef typename mapped_tuple::cons4 cons4;
+      typedef typename mapped_tuple::cons3 cons3;
+      typedef typename mapped_tuple::cons2 cons2;
+      typedef typename mapped_tuple::cons1 cons1;
+
+      typedef typename detail::add_const_reference<T1>::type t1_cref;
+      typedef typename detail::add_const_reference<T2>::type t2_cref;
+      typedef typename detail::add_const_reference<T3>::type t3_cref;
+      typedef typename detail::add_const_reference<T4>::type t4_cref;
+      typedef typename detail::add_const_reference<T5>::type t5_cref;
+      typedef typename detail::add_const_reference<T6>::type t6_cref;
+      typedef typename detail::add_const_reference<T7>::type t7_cref;
+      typedef typename detail::add_const_reference<T8>::type t8_cref;
+      typedef typename detail::add_const_reference<T9>::type t9_cref;
+      typedef typename detail::add_const_reference<T10>::type t10_cref;
+    public:
+      typedef cons1 inherited;
+      typedef tuple self_type;
+
+      tuple() : cons1(T1(), cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
+        {}
+
+      tuple(
+          t1_cref t1,
+          t2_cref t2,
+          t3_cref t3 = T3(),
+          t4_cref t4 = T4(),
+          t5_cref t5 = T5(),
+          t6_cref t6 = T6(),
+          t7_cref t7 = T7(),
+          t8_cref t8 = T8(),
+          t9_cref t9 = T9(),
+          t10_cref t10 = T10()
+      ) :
+        cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10))))))))))
+      {
+      }
+
+      explicit tuple(t1_cref t1)
+        : cons1(t1, cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
+      {}
+
+      template<typename Head, typename Tail>
+      tuple(const cons<Head, Tail>& other) :
+        cons1(other.head, other.tail)
+      {
+      }
+
+      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;
+      }
+    };
+
+    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 detail::get_class<N>::get(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 detail::get_class<N>::get(t);
+    }
+
+    // Make a tuple
+    template<typename T1>
+    inline
+    tuple<T1>
+    make_tuple(const T1& t1)
+    {
+      return tuple<T1>(t1);
+    }
+
+    // Make a tuple
+    template<typename T1, typename T2>
+    inline
+    tuple<T1, T2>
+    make_tuple(const T1& t1, const T2& t2)
+    {
+      return tuple<T1, T2>(t1, t2);
+    }
+
+    // Make a tuple
+    template<typename T1, typename T2, typename T3>
+    inline
+    tuple<T1, T2, T3>
+    make_tuple(const T1& t1, const T2& t2, const T3& t3)
+    {
+      return tuple<T1, T2, T3>(t1, t2, t3);
+    }
+
+    // Make a tuple
+    template<typename T1, typename T2, typename T3, typename T4>
+    inline
+    tuple<T1, T2, T3, T4>
+    make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4)
+    {
+      return tuple<T1, T2, T3, T4>(t1, t2, t3, t4);
+    }
+
+    // Make a tuple
+    template<typename T1, typename T2, typename T3, typename T4, typename T5>
+    inline
+    tuple<T1, T2, T3, T4, T5>
+    make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5)
+    {
+      return tuple<T1, T2, T3, T4, T5>(t1, t2, t3, t4, t5);
+    }
+
+    // Make a tuple
+    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+    inline
+    tuple<T1, T2, T3, T4, T5, T6>
+    make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6)
+    {
+      return tuple<T1, T2, T3, T4, T5, T6>(t1, t2, t3, t4, t5, t6);
+    }
+
+    // Make a tuple
+    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+    inline
+    tuple<T1, T2, T3, T4, T5, T6, T7>
+    make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7)
+    {
+      return tuple<T1, T2, T3, T4, T5, T6, T7>(t1, t2, t3, t4, t5, t6, t7);
+    }
+
+    // Make a tuple
+    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+    inline
+    tuple<T1, T2, T3, T4, T5, T6, T7, T8>
+    make_tuple(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 tuple<T1, T2, T3, T4, T5, T6, T7, T8>(t1, t2, t3, t4, t5, t6, t7, t8);
+    }
+
+    // Make a tuple
+    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+    inline
+    tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
+    make_tuple(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 tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>(t1, t2, t3, t4, t5, t6, t7, t8, t9);
+    }
+
+    // Make 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<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
+    make_tuple(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, const T10& t10)
+    {
+      return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
+    }
+
+    // Tie variables into a tuple
+    template<typename T1>
+    inline
+    tuple<detail::assign_to_pointee<T1> >
+    tie(T1& t1)
+    {
+      return make_tuple(detail::assign_to_pointee<T1>(&t1));
+    }
+
+    // Tie variables into a tuple
+    template<typename T1, typename T2>
+    inline
+    tuple<detail::assign_to_pointee<T1>,
+      detail::assign_to_pointee<T2> >
+    tie(T1& t1, 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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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".
+
+detail::swallow_assign const ignore = detail::swallow_assign();
+
+} // namespace tuples
+} // namespace boost
+#endif // BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP

include/boost/tuple/tuple.hpp

@@ -0,0 +1,90 @@
+//  tuple.hpp - Boost Tuple Library --------------------------------------
+
+// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+
+// ----------------------------------------------------------------- 
+
+#ifndef BOOST_TUPLE_HPP
+#define BOOST_TUPLE_HPP
+
+#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
+// Work around a compiler bug.
+// boost::python::tuple has to be seen by the compiler before the
+// boost::tuple class template.
+namespace boost { namespace python { class tuple; }}
+#endif
+
+#include "boost/config.hpp"
+#include "boost/static_assert.hpp"
+
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+// The MSVC version
+#include "boost/tuple/detail/tuple_basic_no_partial_spec.hpp"
+
+#else
+// other compilers
+#include "boost/ref.hpp"
+#include "boost/tuple/detail/tuple_basic.hpp"
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+namespace boost {    
+
+using tuples::tuple;
+using tuples::make_tuple;
+using tuples::tie;
+#if !defined(BOOST_NO_USING_TEMPLATE)
+using tuples::get;
+#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+//
+// The "using tuples::get" statement causes the
+// Borland compiler to ICE, use forwarding
+// functions instead:
+//
+template<int N, class HT, class TT>
+inline typename tuples::access_traits<
+                  typename tuples::element<N, tuples::cons<HT, TT> >::type
+                >::non_const_type
+get(tuples::cons<HT, TT>& c) {
+  return tuples::get<N,HT,TT>(c);
+} 
+// get function for const cons-lists, returns a const reference to
+// the element. If the element is a reference, returns the reference
+// as such (that is, can return a non-const reference)
+template<int N, class HT, class TT>
+inline typename tuples::access_traits<
+                  typename tuples::element<N, tuples::cons<HT, TT> >::type
+                >::const_type
+get(const tuples::cons<HT, TT>& c) {
+  return tuples::get<N,HT,TT>(c);
+}
+#else  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+//
+// MSVC, using declarations don't mix with templates well,
+// so use forwarding functions instead:
+//
+template<int N, typename Head, typename Tail>
+typename tuples::detail::element_ref<N, tuples::cons<Head, Tail> >::RET
+get(tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0)
+{
+   return tuples::detail::get_class<N>::get(t);
+}
+
+template<int N, typename Head, typename Tail>
+typename tuples::detail::element_const_ref<N, tuples::cons<Head, Tail> >::RET
+get(const tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0)
+{
+   return tuples::detail::get_class<N>::get(t);
+}
+#endif // BOOST_NO_USING_TEMPLATE
+   
+} // end namespace boost
+
+
+#endif // BOOST_TUPLE_HPP

include/boost/tuple/tuple_comparison.hpp

@@ -0,0 +1,175 @@
+// tuple_comparison.hpp -----------------------------------------------------
+//  
+// Copyright (C) 2001 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// 
+// For more information, see http://www.boost.org
+// 
+// (The idea and first impl. of comparison operators was from Doug Gregor)
+
+// ----------------------------------------------------------------- 
+
+#ifndef BOOST_TUPLE_COMPARISON_HPP
+#define BOOST_TUPLE_COMPARISON_HPP
+
+#include "boost/tuple/tuple.hpp"
+
+// -------------------------------------------------------------
+// equality and comparison operators 
+//
+// == and != compare tuples elementwise
+// <, >, <= and >= use lexicographical ordering
+//
+// Any operator between tuples of different length fails at compile time
+// No dependencies between operators are assumed 
+// (i.e. !(a<b)  does not imply a>=b, a!=b does not imply a==b etc.
+// so any weirdnesses of elementary operators are respected).
+//
+// -------------------------------------------------------------
+
+
+namespace boost {
+namespace tuples {
+
+inline bool operator==(const null_type&, const null_type&) { return true; }
+inline bool operator>=(const null_type&, const null_type&) { return true; }
+inline bool operator<=(const null_type&, const null_type&) { return true; }
+inline bool operator!=(const null_type&, const null_type&) { return false; }
+inline bool operator<(const null_type&, const null_type&) { return false; }
+inline bool operator>(const null_type&, const null_type&) { return false; }
+
+
+namespace detail {
+  // comparison operators check statically the length of its operands and
+  // delegate the comparing task to the following functions. Hence
+  // the static check is only made once (should help the compiler).  
+  // These functions assume tuples to be of the same length.
+
+
+template<class T1, class T2>
+inline bool eq(const T1& lhs, const T2& rhs) {
+  return lhs.get_head() == rhs.get_head() &&
+         eq(lhs.get_tail(), rhs.get_tail());
+}
+template<>
+inline bool eq<null_type,null_type>(const null_type&, const null_type&) { return true; }
+
+template<class T1, class T2>
+inline bool neq(const T1& lhs, const T2& rhs) {
+  return lhs.get_head() != rhs.get_head()  ||
+         neq(lhs.get_tail(), rhs.get_tail());
+}
+template<>
+inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return false; }
+
+template<class T1, class T2>
+inline bool lt(const T1& lhs, const T2& rhs) {
+  return lhs.get_head() < rhs.get_head()  ||
+            !(rhs.get_head() < lhs.get_head()) &&
+            lt(lhs.get_tail(), rhs.get_tail());
+}
+template<>
+inline bool lt<null_type,null_type>(const null_type&, const null_type&) { return false; }
+
+template<class T1, class T2>
+inline bool gt(const T1& lhs, const T2& rhs) {
+  return lhs.get_head() > rhs.get_head()  ||
+            !(rhs.get_head() > lhs.get_head()) &&
+            gt(lhs.get_tail(), rhs.get_tail());
+}
+template<>
+inline bool gt<null_type,null_type>(const null_type&, const null_type&) { return false; }
+
+template<class T1, class T2>
+inline bool lte(const T1& lhs, const T2& rhs) {
+  return lhs.get_head() <= rhs.get_head()  &&
+          ( !(rhs.get_head() <= lhs.get_head()) ||
+            lte(lhs.get_tail(), rhs.get_tail()));
+}
+template<>
+inline bool lte<null_type,null_type>(const null_type&, const null_type&) { return true; }
+
+template<class T1, class T2>
+inline bool gte(const T1& lhs, const T2& rhs) {
+  return lhs.get_head() >= rhs.get_head()  &&
+          ( !(rhs.get_head() >= lhs.get_head()) ||
+            gte(lhs.get_tail(), rhs.get_tail()));
+}
+template<>
+inline bool gte<null_type,null_type>(const null_type&, const null_type&) { return true; }
+
+} // end of namespace detail
+
+
+// equal ----
+
+template<class T1, class T2, class S1, class S2>
+inline bool operator==(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
+{
+  // check that tuple lengths are equal
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
+
+  return  detail::eq(lhs, rhs);
+}
+
+// not equal -----
+
+template<class T1, class T2, class S1, class S2>
+inline bool operator!=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
+{
+
+  // check that tuple lengths are equal
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
+
+  return detail::neq(lhs, rhs);
+}
+
+// <
+template<class T1, class T2, class S1, class S2>
+inline bool operator<(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
+{
+  // check that tuple lengths are equal
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
+
+  return detail::lt(lhs, rhs);
+}
+
+// >
+template<class T1, class T2, class S1, class S2>
+inline bool operator>(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
+{
+  // check that tuple lengths are equal
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
+
+  return detail::gt(lhs, rhs);
+}
+
+// <=
+template<class T1, class T2, class S1, class S2>
+inline bool operator<=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
+{
+  // check that tuple lengths are equal
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
+
+  return detail::lte(lhs, rhs);
+}
+
+// >=
+template<class T1, class T2, class S1, class S2>
+inline bool operator>=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
+{
+  // check that tuple lengths are equal
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
+
+  return detail::gte(lhs, rhs);
+}
+
+} // end of namespace tuples
+} // end of namespace boost
+
+
+#endif // BOOST_TUPLE_COMPARISON_HPP

include/boost/tuple/tuple_io.hpp

@@ -0,0 +1,525 @@
+// tuple_io.hpp --------------------------------------------------------------
+
+// Copyright (C) 2001 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
+//               2001 Gary Powell (gary.powell@sierra.com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// For more information, see http://www.boost.org 
+
+// ----------------------------------------------------------------------------
+
+#ifndef BOOST_TUPLE_IO_HPP
+#define BOOST_TUPLE_IO_HPP
+
+
+// add to boost/config.hpp
+// for now
+# if defined __GNUC__
+#   if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97) 
+#define BOOST_NO_TEMPLATED_STREAMS
+#endif
+#endif // __GNUC__
+
+#if defined BOOST_NO_TEMPLATED_STREAMS
+#include <iostream>
+#else 
+#include <istream>
+#include <ostream>
+#endif  
+
+#include "boost/tuple/tuple.hpp"
+
+// This is ugly: one should be using twoargument isspace since whitspace can
+// be locale dependent, in theory at least.
+// not all libraries implement have the two-arg version, so we need to 
+// use the one-arg one, which one should get with <cctype> but there seem
+// to be exceptions to this.
+
+#if !defined (BOOST_NO_STD_LOCALE)
+
+#include <locale> // for two-arg isspace
+
+#else 
+
+#include <cctype> // for one-arg (old) isspace 
+#include <ctype.h> // Metrowerks does not find one-arg isspace from cctype
+
+#endif
+
+namespace boost {
+namespace tuples {
+
+namespace detail {
+
+class format_info {
+public:   
+
+   enum manipulator_type { open, close, delimiter };
+   BOOST_STATIC_CONSTANT(int, number_of_manipulators = delimiter + 1);
+private:
+   
+   static int get_stream_index (int m)
+   {
+     static const int stream_index[number_of_manipulators]
+        = { std::ios::xalloc(), std::ios::xalloc(), std::ios::xalloc() };
+
+     return stream_index[m];
+   }
+
+   format_info(const format_info&);
+   format_info();   
+
+
+public:
+
+#if defined (BOOST_NO_TEMPLATED_STREAMS)
+   static char get_manipulator(std::ios& i, manipulator_type m) {
+     char c = static_cast<char>(i.iword(get_stream_index(m))); 
+     
+     // parentheses and space are the default manipulators
+     if (!c) {
+       switch(m) {
+         case detail::format_info::open : c = '('; break;
+         case detail::format_info::close : c = ')'; break;
+         case detail::format_info::delimiter : c = ' '; break;
+       }
+     }
+     return c;
+   }
+
+   static void set_manipulator(std::ios& i, manipulator_type m, char c) {
+      i.iword(get_stream_index(m)) = static_cast<long>(c);
+   }
+#else
+   template<class CharType, class CharTrait>
+   static CharType get_manipulator(std::basic_ios<CharType, CharTrait>& i, 
+                                   manipulator_type m) {
+     // The manipulators are stored as long.
+     // A valid instanitation of basic_stream allows CharType to be any POD,
+     // hence, the static_cast may fail (it fails if long is not convertible 
+     // to CharType
+     CharType c = static_cast<CharType>(i.iword(get_stream_index(m)) ); 
+     // parentheses and space are the default manipulators
+     if (!c) {
+       switch(m) {
+         case detail::format_info::open :  c = i.widen('('); break;
+         case detail::format_info::close : c = i.widen(')'); break;
+         case detail::format_info::delimiter : c = i.widen(' '); break;
+       }
+     }
+     return c;
+   }
+
+
+   template<class CharType, class CharTrait>
+   static void set_manipulator(std::basic_ios<CharType, CharTrait>& i, 
+                               manipulator_type m, CharType c) {
+     // The manipulators are stored as long.
+     // A valid instanitation of basic_stream allows CharType to be any POD,
+     // hence, the static_cast may fail (it fails if CharType is not 
+     // convertible long.
+      i.iword(get_stream_index(m)) = static_cast<long>(c);
+   }
+#endif // BOOST_NO_TEMPLATED_STREAMS
+};
+
+} // end of namespace detail
+ 
+template<class CharType>    
+class tuple_manipulator {
+  const detail::format_info::manipulator_type mt;
+  CharType f_c;
+public:
+  explicit tuple_manipulator(detail::format_info::manipulator_type m, 
+                             const char c = 0)
+     : mt(m), f_c(c) {}
+  
+#if defined (BOOST_NO_TEMPLATED_STREAMS)
+  void set(std::ios &io) const {
+     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 {
+     detail::format_info::set_manipulator(io, mt, f_c);
+  }
+#else
+   template<class CharTrait>
+  void set(std::basic_ios<CharType, CharTrait> &io) const {
+     detail::format_info::set_manipulator(io, mt, f_c);
+  }
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif // BOOST_NO_TEMPLATED_STREAMS
+};
+
+#if defined (BOOST_NO_TEMPLATED_STREAMS)
+inline std::ostream&
+operator<<(std::ostream& o, const tuple_manipulator<char>& m) {
+  m.set(o);
+  return o;
+}
+
+inline std::istream&
+operator>>(std::istream& i, const tuple_manipulator<char>& m) {
+  m.set(i);
+  return i;
+}
+
+#else
+
+template<class CharType, class CharTrait>
+inline std::basic_ostream<CharType, CharTrait>&
+operator<<(std::basic_ostream<CharType, CharTrait>& o, const tuple_manipulator<CharType>& m) {
+  m.set(o);
+  return o;
+}
+
+template<class CharType, class CharTrait>
+inline std::basic_istream<CharType, CharTrait>&
+operator>>(std::basic_istream<CharType, CharTrait>& i, const tuple_manipulator<CharType>& m) {
+  m.set(i);
+  return i;
+}
+
+#endif   // BOOST_NO_TEMPLATED_STREAMS
+   
+template<class CharType>
+inline tuple_manipulator<CharType> set_open(const CharType c) {
+   return tuple_manipulator<CharType>(detail::format_info::open, c);
+}
+
+template<class CharType>
+inline tuple_manipulator<CharType> set_close(const CharType c) {
+   return tuple_manipulator<CharType>(detail::format_info::close, c);
+}
+
+template<class CharType>
+inline tuple_manipulator<CharType> set_delimiter(const CharType c) {
+   return tuple_manipulator<CharType>(detail::format_info::delimiter, c);
+}
+
+
+
+   
+   
+// -------------------------------------------------------------
+// printing tuples to ostream in format (a b c)
+// parentheses and space are defaults, but can be overriden with manipulators
+// set_open, set_close and set_delimiter
+   
+namespace detail {
+
+// Note: The order of the print functions is critical 
+// to let a conforming compiler  find and select the correct one.
+
+#if defined (BOOST_NO_TEMPLATED_STREAMS)
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+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
+ 
+inline std::ostream& print(std::ostream& o, const null_type&) { return o; }
+
+template<class T1, class T2>
+inline std::ostream& 
+print(std::ostream& o, const cons<T1, T2>& t) {
+  
+  const char d = format_info::get_manipulator(o, format_info::delimiter);
+   
+  o << t.head;
+
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+  if (tuples::length<T2>::value == 0)
+    return o;
+#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  o << d;
+  
+  return print(o, t.tail );
+
+}
+
+
+
+#else
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+template<class CharType, class CharTrait, class T1>
+inline std::basic_ostream<CharType, CharTrait>& 
+print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, null_type>& t) {
+  return o << t.head;
+}
+#endif  // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+ 
+template<class CharType, class CharTrait>
+inline std::basic_ostream<CharType, CharTrait>& 
+print(std::basic_ostream<CharType, CharTrait>& o, const null_type&) { 
+  return o; 
+}
+
+template<class CharType, class CharTrait, class T1, class T2>
+inline std::basic_ostream<CharType, CharTrait>& 
+print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, T2>& t) {
+  
+  const CharType d = format_info::get_manipulator(o, format_info::delimiter);
+   
+  o << t.head;
+
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+  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
+
+} // namespace detail
+
+#if defined (BOOST_NO_TEMPLATED_STREAMS)
+template<class T1, class T2>
+inline std::ostream& operator<<(std::ostream& o, const cons<T1, T2>& t) {
+  if (!o.good() ) return o;
+ 
+  const char l = 
+    detail::format_info::get_manipulator(o, detail::format_info::open);
+  const char r = 
+    detail::format_info::get_manipulator(o, detail::format_info::close);
+   
+  o << l;
+  
+  detail::print(o, t);  
+
+  o << r;
+
+  return o;
+}
+
+#else
+
+template<class CharType, class CharTrait, class T1, class T2>
+inline std::basic_ostream<CharType, CharTrait>& 
+operator<<(std::basic_ostream<CharType, CharTrait>& o, 
+           const cons<T1, T2>& t) {
+  if (!o.good() ) return o;
+ 
+  const CharType l = 
+    detail::format_info::get_manipulator(o, detail::format_info::open);
+  const CharType r = 
+    detail::format_info::get_manipulator(o, detail::format_info::close);
+   
+  o << l;   
+
+  detail::print(o, t);  
+
+  o << r;
+
+  return o;
+}
+#endif // BOOST_NO_TEMPLATED_STREAMS
+
+   
+// -------------------------------------------------------------
+// input stream operators
+
+namespace detail {
+
+#if defined (BOOST_NO_TEMPLATED_STREAMS)
+
+inline std::istream& 
+extract_and_check_delimiter(
+  std::istream& is, format_info::manipulator_type del)
+{
+  const char d = format_info::get_manipulator(is, del);
+
+#if defined (BOOST_NO_STD_LOCALE)
+  const bool is_delimiter = !isspace(d);
+#else
+  const bool is_delimiter = (!std::isspace(d, is.getloc()) );            
+#endif
+
+  char c;
+  if (is_delimiter) { 
+    is >> c; 
+    if (is.good() && c!=d) {
+      is.setstate(std::ios::failbit);
+    } 
+  }
+  return is;
+}
+
+
+// Note: The order of the read functions is critical to let a 
+// (conforming?) compiler find and select the correct one.
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+template<class T1>
+inline  std::istream & 
+read (std::istream &is, cons<T1, null_type>& t1) {
+
+  if (!is.good()) return is;   
+   
+  return is >> t1.head ;
+}
+#else
+inline std::istream& read(std::istream& i, const null_type&) { return i; }
+#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   
+template<class T1, class T2>
+inline std::istream& 
+read(std::istream &is, cons<T1, T2>& t1) {
+
+  if (!is.good()) return is;
+   
+  is >> t1.head;
+
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+  if (tuples::length<T2>::value == 0)
+    return is;
+#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+  extract_and_check_delimiter(is, format_info::delimiter);
+
+  return read(is, t1.tail);
+}
+
+} // end namespace detail
+
+inline std::istream& 
+operator>>(std::istream &is, null_type&) {
+
+  if (!is.good() ) return is;
+
+  detail::extract_and_check_delimiter(is, detail::format_info::open);
+  detail::extract_and_check_delimiter(is, detail::format_info::close);
+
+  return is;
+}
+
+
+template<class T1, class T2>
+inline std::istream& 
+operator>>(std::istream& is, cons<T1, T2>& t1) {
+
+  if (!is.good() ) return is;
+
+  detail::extract_and_check_delimiter(is, detail::format_info::open);
+                      
+  detail::read(is, t1);
+   
+  detail::extract_and_check_delimiter(is, detail::format_info::close);
+
+  return is;
+}
+
+
+
+#else
+
+template<class CharType, class CharTrait>
+inline std::basic_istream<CharType, CharTrait>& 
+extract_and_check_delimiter(
+  std::basic_istream<CharType, CharTrait> &is, format_info::manipulator_type del)
+{
+  const CharType d = format_info::get_manipulator(is, del);
+
+#if defined (BOOST_NO_STD_LOCALE)
+  const bool is_delimiter = !isspace(d);
+#elif defined ( __BORLANDC__ )
+  const bool is_delimiter = !std::use_facet< std::ctype< CharType > >
+    (is.getloc() ).is( std::ctype_base::space, d);
+#else
+  const bool is_delimiter = (!std::isspace(d, is.getloc()) );            
+#endif
+
+  CharType c;
+  if (is_delimiter) { 
+    is >> c;
+    if (is.good() && c!=d) { 
+      is.setstate(std::ios::failbit);
+    }
+  }
+  return is;
+}
+
+   
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+template<class CharType, class CharTrait, class T1>
+inline  std::basic_istream<CharType, CharTrait> & 
+read (std::basic_istream<CharType, CharTrait> &is, cons<T1, null_type>& t1) {
+
+  if (!is.good()) return is;   
+   
+  return is >> t1.head; 
+}
+#else
+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
+
+template<class CharType, class CharTrait, class T1, class T2>
+inline std::basic_istream<CharType, CharTrait>& 
+read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) {
+
+  if (!is.good()) return is;
+   
+  is >> t1.head;
+
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+  if (tuples::length<T2>::value == 0)
+    return is;
+#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+  extract_and_check_delimiter(is, format_info::delimiter);
+
+  return read(is, t1.tail);
+}
+
+} // end namespace detail
+
+
+template<class CharType, class CharTrait>
+inline std::basic_istream<CharType, CharTrait>& 
+operator>>(std::basic_istream<CharType, CharTrait> &is, null_type&) {
+
+  if (!is.good() ) return is;
+
+  detail::extract_and_check_delimiter(is, detail::format_info::open);
+  detail::extract_and_check_delimiter(is, detail::format_info::close);
+
+  return is;
+}
+
+template<class CharType, class CharTrait, class T1, class T2>
+inline std::basic_istream<CharType, CharTrait>& 
+operator>>(std::basic_istream<CharType, CharTrait>& is, cons<T1, T2>& t1) {
+
+  if (!is.good() ) return is;
+
+  detail::extract_and_check_delimiter(is, detail::format_info::open);
+                      
+  detail::read(is, t1);
+   
+  detail::extract_and_check_delimiter(is, detail::format_info::close);
+
+  return is;
+}
+
+#endif // BOOST_NO_TEMPLATED_STREAMS
+
+} // end of namespace tuples
+} // end of namespace boost
+
+#endif // BOOST_TUPLE_IO_HPP
+
+

index.html

@@ -3,6 +3,11 @@
 <meta http-equiv="refresh" content="0; URL=doc/tuple_users_guide.html">
 </head>
 <body>
-Automatic redirection failed, please go to <a href="doc/tuple_users_guide.html">doc/tuple_users_guide.html</a>
+Automatic redirection failed, please go to <a href="doc/tuple_users_guide.html">doc/tuple_users_guide.html</a> 
+&nbsp;<hr>
+<p><EFBFBD> Copyright Beman Dawes, 2001</p>
+<p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
+file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
+at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
 </body>
-</html>
+</html>

test/Jamfile

@@ -1,20 +1,8 @@
-subproject libs/tuple/test ;
 
-unit-test tuple_test_bench
-    : tuple_test_bench.cpp
-      <lib>../../test/build/boost_test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-
-unit-test io_test
-    : io_test.cpp
-      <lib>../../test/build/boost_test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-
-unit-test another_tuple_test_bench
-    : another_tuple_test_bench.cpp
-      <lib>../../test/build/boost_test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
+project : requirements <library>/boost/test//boost_test_exec_monitor ;
 
+test-suite tuple : 
+    [ run tuple_test_bench.cpp ]
+    [ run io_test.cpp ]
+    [ run another_tuple_test_bench.cpp ]
+    ;

test/io_test.cpp

@@ -52,7 +52,7 @@ int test_main(int argc, char * argv[] ) {
   os1 << set_close(']');
   os1 << set_delimiter(',');
   os1 << make_tuple(1, 2, 3);
-  BOOST_TEST (os1.str() == std::string("[1,2,3]") );
+  BOOST_CHECK (os1.str() == std::string("[1,2,3]") );
 
   {
   useThisOStringStream os2;
@@ -62,13 +62,13 @@ int test_main(int argc, char * argv[] ) {
   os2 << set_delimiter(':');
 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   os2 << make_tuple("TUPU", "HUPU", "LUPU", 4.5);
-  BOOST_TEST (os2.str() == std::string("(TUPU:HUPU:LUPU:4.5)") );
+  BOOST_CHECK (os2.str() == std::string("(TUPU:HUPU:LUPU:4.5)") );
 #endif
   }
 
   // The format is still [a, b, c] for os1
   os1 << make_tuple(1, 2, 3);
-  BOOST_TEST (os1.str() == std::string("[1,2,3][1,2,3]") );
+  BOOST_CHECK (os1.str() == std::string("[1,2,3][1,2,3]") );
 
   ofstream tmp("temp.tmp");
 
@@ -86,13 +86,13 @@ int test_main(int argc, char * argv[] ) {
 
 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   tmp3 >> j; 
-  BOOST_TEST (tmp3.good() ); 
+  BOOST_CHECK (tmp3.good() ); 
 #endif
    
   tmp3 >> set_delimiter(':');
   tuple<int, int, int> i;
   tmp3 >> i; 
-  BOOST_TEST (tmp3.good() ); 
+  BOOST_CHECK (tmp3.good() ); 
    
   tmp3.close(); 
 
@@ -101,8 +101,8 @@ int test_main(int argc, char * argv[] ) {
   useThisIStringStream is("(100 200 300)"); 
    
   tuple<int, int, int> ti; 
-  BOOST_TEST(bool(is >> ti));
-  BOOST_TEST(ti == make_tuple(100, 200, 300));
+  BOOST_CHECK(bool(is >> ti));
+  BOOST_CHECK(ti == make_tuple(100, 200, 300));
    
 
   // Note that strings are problematic:

test/tuple_test_bench.cpp

@@ -107,32 +107,32 @@ construction_test()
   // MSVC 6.0 just cannot find get without the namespace qualifier
 
   tuple<int> t1;
-  BOOST_TEST(get<0>(t1) == int());
+  BOOST_CHECK(get<0>(t1) == int());
 
   tuple<float> t2(5.5f);
-  BOOST_TEST(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f);
+  BOOST_CHECK(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f);
 
   tuple<foo> t3(foo(12));
-  BOOST_TEST(get<0>(t3) == foo(12));
+  BOOST_CHECK(get<0>(t3) == foo(12));
 
   tuple<double> t4(t2);
-  BOOST_TEST(get<0>(t4) > 5.4 && get<0>(t4) < 5.6);
+  BOOST_CHECK(get<0>(t4) > 5.4 && get<0>(t4) < 5.6);
 
   tuple<int, float> t5;
-  BOOST_TEST(get<0>(t5) == int());
-  BOOST_TEST(get<1>(t5) == float());
+  BOOST_CHECK(get<0>(t5) == int());
+  BOOST_CHECK(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);
+  BOOST_CHECK(get<0>(t6) == 12);
+  BOOST_CHECK(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);
+  BOOST_CHECK(get<0>(t7) == 12);
+  BOOST_CHECK(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);
+  BOOST_CHECK(get<0>(t8) == 12);
+  BOOST_CHECK(get<1>(t8) > 5.4f && get<1>(t8) < 5.6f);
 
   dummy(
     tuple<no_def_constructor, no_def_constructor, no_def_constructor>(
@@ -175,27 +175,27 @@ void element_access_test()
   int i  = get<0>(t);
   int i2 = get<3>(t);
 
-  BOOST_TEST(i == 1 && i2 == 2);
+  BOOST_CHECK(i == 1 && i2 == 2);
 
   int j  = get<0>(ct);
-  BOOST_TEST(j == 1);
+  BOOST_CHECK(j == 1);
    
   get<0>(t) = 5;
-  BOOST_TEST(t.head == 5);
+  BOOST_CHECK(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);
+  BOOST_CHECK(e > 2.69 && e < 2.71);
      
   get<1>(t) = 3.14+i;
-  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
+  BOOST_CHECK(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);
+  BOOST_CHECK(get<0>(t) == 6);
 
   BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<0, tuple<int, float> >::type>::value != true));
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
@@ -224,13 +224,13 @@ 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));
+  BOOST_CHECK(get<0>(t1) == get<0>(t2));
+  BOOST_CHECK(get<1>(t1) == get<1>(t2));
 
   tuple<long, std::string> t3(2, "a");
   t3 = t1;
-  BOOST_TEST((double)get<0>(t1) == get<0>(t3));
-  BOOST_TEST(get<1>(t1) == get<1>(t3)[0]);
+  BOOST_CHECK((double)get<0>(t1) == get<0>(t3));
+  BOOST_CHECK(get<1>(t1) == get<1>(t3)[0]);
 
 // testing copy and assignment with implicit conversions between elements
 // testing tie
@@ -242,9 +242,9 @@ copy_test()
   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);
+  BOOST_CHECK(i==1);
+  BOOST_CHECK(c=='a');
+  BOOST_CHECK(d>5.4 && d<5.6);
 }
 
 void
@@ -256,10 +256,10 @@ mutate_test()
   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));
+  BOOST_CHECK(get<0>(t1) == 6);
+  BOOST_CHECK(get<1>(t1) > 2.1f && get<1>(t1) < 2.3f);
+  BOOST_CHECK(get<2>(t1) == false);
+  BOOST_CHECK(get<3>(t1) == foo(5));
 }
 
 // ----------------------------------------------------------------------------
@@ -270,13 +270,13 @@ void
 make_tuple_test()
 {
   tuple<int, char> t1 = make_tuple(5, 'a');
-  BOOST_TEST(get<0>(t1) == 5);
-  BOOST_TEST(get<1>(t1) == 'a');
+  BOOST_CHECK(get<0>(t1) == 5);
+  BOOST_CHECK(get<1>(t1) == 'a');
 
   tuple<int, std::string> t2;
   t2 = make_tuple((short int)2, std::string("Hi"));
-  BOOST_TEST(get<0>(t2) == 2);
-  BOOST_TEST(get<1>(t2) == "Hi");
+  BOOST_CHECK(get<0>(t2) == 2);
+  BOOST_CHECK(get<1>(t2) == "Hi");
 
 
     A a = A(); B b;
@@ -288,7 +288,7 @@ make_tuple_test()
     make_tuple(boost::ref(ca));
      
 // the result of make_tuple is assignable:
-   BOOST_TEST(make_tuple(2, 4, 6) == 
+   BOOST_CHECK(make_tuple(2, 4, 6) == 
              (make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));
 
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
@@ -336,19 +336,19 @@ tie_test()
   foo c(5);
 
   tie(a, b, c) = make_tuple(2, 'a', foo(3));
-  BOOST_TEST(a == 2);
-  BOOST_TEST(b == 'a');
-  BOOST_TEST(c == foo(3));
+  BOOST_CHECK(a == 2);
+  BOOST_CHECK(b == 'a');
+  BOOST_CHECK(c == foo(3));
 
   tie(a, tuples::ignore, c) = make_tuple((short int)5, false, foo(5));
-  BOOST_TEST(a == 5);
-  BOOST_TEST(b == 'a');
-  BOOST_TEST(c == foo(5));
+  BOOST_CHECK(a == 5);
+  BOOST_CHECK(b == 'a');
+  BOOST_CHECK(c == foo(5));
 
 // testing assignment from std::pair
    int i, j; 
    tie (i, j) = std::make_pair(1, 2);
-   BOOST_TEST(i == 1 && j == 2);
+   BOOST_CHECK(i == 1 && j == 2);
 
    tuple<int, int, float> ta;
 #ifdef E11
@@ -368,13 +368,13 @@ equality_test()
 {
   tuple<int, char> t1(5, 'a');
   tuple<int, char> t2(5, 'a');
-  BOOST_TEST(t1 == t2);
+  BOOST_CHECK(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));
+  BOOST_CHECK(t1 != t3);
+  BOOST_CHECK(t1 != t4);
+  BOOST_CHECK(!(t1 != t2));
 }
 
 
@@ -388,14 +388,14 @@ ordering_test()
   tuple<int, float> t1(4, 3.3f);
   tuple<short, float> t2(5, 3.3f);
   tuple<long, double> t3(5, 4.4);
-  BOOST_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);
+  BOOST_CHECK(t1 < t2);
+  BOOST_CHECK(t1 <= t2);
+  BOOST_CHECK(t2 > t1);
+  BOOST_CHECK(t2 >= t1);
+  BOOST_CHECK(t2 < t3);
+  BOOST_CHECK(t2 <= t3);
+  BOOST_CHECK(t3 > t2);
+  BOOST_CHECK(t3 >= t2);
 
 }
 
@@ -412,7 +412,7 @@ void cons_test()
   cons<const int, cons<volatile float, null_type> > b(2,a);
   int i = 3;
   cons<int&, cons<const int, cons<volatile float, null_type> > > c(i, b);
-  BOOST_TEST(make_tuple(3,2,1)==c);
+  BOOST_CHECK(make_tuple(3,2,1)==c);
 
   cons<char, cons<int, cons<float, null_type> > > x;
   dummy(x);
@@ -424,8 +424,8 @@ void cons_test()
 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);
+  BOOST_CHECK(get<0>(t1) == 5);
+  BOOST_CHECK(get<1>(t1) == 3.3f);
 }
 
 // ----------------------------------------------------------------------------