This commit was manufactured by cvs2svn to create branch

'compiler_supported_error_messages'.

[SVN r13249]

doc/tuple_advanced_interface.html

@@ -20,9 +20,7 @@ Suppose <code>T</code> is a tuple type, and <code>N</code> is a constant integra
 
 <code><pre>element&lt;N, T&gt;::type</pre></code>
 
-gives the type of the <code>N</code>th element in the tuple type <code>T</code>. If <code>T</code> is const, the resulting type is const qualified as well. 
-Note that the constness of <code>T</code> does not affect reference type
-elements.
+gives the type of the <code>N</code>th element in the tuple type <code>T</code>.
 </p>
 
 <code><pre>length&lt;T&gt;::value</pre></code>

doc/tuple_users_guide.html

@@ -74,14 +74,22 @@ Both <code>tuple_io.hpp</code> and <code>tuple_comparison.hpp</code> include <co
 The template parameters specify the types of the tuple elements.
 The current version supports tuples with 0-10 elements. 
 If necessary, the upper limit can be increased up to, say, a few dozen elements.
-The data element can be any C++ type.
-Note that <code>void</code> and plain function types are valid 
-C++ types, but objects of such types cannot exist. 
-Hence, if a tuple type contains such types as elements, the tuple type
-can exist, but not an object of that type.
-There are natural limitations for element types that cannot
-be be copied, or that are not default constructible (see 'Constructing tuples'
- below). 
+The data element can be any C++ type, except for a non-reference type
+that is not copy constructible from a const qualified reference to that
+same type. In practice this means, that the element type must be <i>CopyConstructible</i> [C++ Standard 20.1.3]. (To be precise, CopyConstrucible is an unnecessary strong requirement for a valid element type, as the <code>operator&amp;</code> is not used by the library.)
+</p>
+
+<p>
+Examples of types that are not allowed as tuple elements:
+
+<ul>
+<li>classes that do not have a public copy constructor</li>
+<li>classes, where the copy constructor takes its argument as a non-const reference (cf. <code>auto_ptr</code>)
+<li>arrays</li>
+</ul>
+
+Note that a reference to any of these non-copyable types is a valid element
+type.
 
 <p>
 For example, the following definitions are valid tuple instantiations (<code>A</code>, <code>B</code> and <code>C</code> are some user defined classes):
@@ -93,11 +101,26 @@ tuple&lt;std::string, std::pair&lt;A, B&gt; &gt;
 tuple&lt;A*, tuple&lt;const A*, const B&amp;, C&gt;, bool, void*&gt;
 </code></pre>
 
+<p>
+The following code shows some invalid tuple instantiations:
+<pre><code>class Y { 
+  Y(const Y&amp;); 
+public:
+  Y();
+};
+
+tuple&lt;Y&gt;        // not allowed, objects of type Y cannot be copied
+tuple&lt;char[10]&gt; // not allowed: arrays cannot be copied
+</code></pre>
+
+Note however that <code>tuple&lt;Y&amp;&gt;</code> and <code>tuple&lt;char(&)[10]&gt;</code> are valid instantiations.
+
+
 <h2><a name = "constructing_tuples">Constructing tuples</a></h2>
 
 <p>
 The tuple constructor takes the tuple elements as arguments. 
-For an <i>n</i>-element tuple, the constructor can be invoked with <i>k</i> arguments, where 0 &lt;= <i>k</i> &lt;= <i>n</i>.
+For an <i>n</i>-element tuple, the constructor can be invoked with <i>k</i> arguments, where 0 &lt; <i>k</i> &lt;= <i>n</i>.
 For example:
 <pre><code>tuple&lt;int, double&gt;() 
 tuple&lt;int, double&gt;(1) 
@@ -133,31 +156,6 @@ tuple&lt;const double&amp;&gt;(d+3.14)    // ok, but dangerous:
                                 // the element becomes a dangling reference 
 </code></pre>
 
-<p>Using an initial value for an element that cannot be copied, is a compile
-time error:
-
-<pre><code>class Y { 
-  Y(const Y&amp;); 
-public:
-  Y();
-};
-
-char a[10];
-
-tuple&lt;char[10], Y&gt;(a, Y()); // error, neither arrays nor Y can be copied
-tuple&lt;char[10], Y&gt;();       // ok
-</code></pre>
-
-Note particularly that the following is perfectly ok:
-<code><pre>Y y;
-tuple&lt;char(&amp;)[10], Y&amp;&gt;(a, y); 
-</code></pre>
-
-It is possible to come up with a tuple type that cannot be constructed.
-This occurs if an element that cannot be initialized has a lower
-index than an element that requires initialization. 
-For example: <code>tuple&lt;char[10], int&amp;&gt;</code>.
-
 <p>In sum, the tuple construction is semantically just a group of individual elementary constructions.
 </p>
 
@@ -264,10 +262,10 @@ A tuple can be copy constructed from another tuple, provided that the element ty
 Analogously, a tuple can be assigned to another tuple, provided that the element types are element-wise assignable.
 For example:
 
-<pre><code>class A {};
+<pre><code>class A;
 class B : public A {};
-struct C { C(); C(const B&amp;); };
-struct D { operator C() const; };
+struct C { C(); C(const B&amp;); }
+struct D { operator C() const; }
 tuple&lt;char, B*, B, D&gt; t;
   ...
 tuple&lt;int, A*, C, C&gt; a(t); // ok 

include/boost/tuple/detail/tuple_basic.hpp

@@ -19,15 +19,10 @@
 // ( and other bugs ) per suggestion of Jens Maurer
 // simplified element type accessors + bug fix  (Jeremy Siek)
 // Several changes/additions according to suggestions by Doug Gregor, 
-// William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes,
+// William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Davis,
 // David Abrahams.
 
 // Revision history:
-// 2002 05 01 Hugo Duncan: Fix for Borland after Jaakko's previous changes
-// 2002 04 18 Jaakko: tuple element types can be void or plain function 
-//                    types, as long as no object is created.
-//                    Tuple objects can no hold even noncopyable types
-//                    such as arrays.             
 // 2001 10 22 John Maddock
 //      Fixes for Borland C++
 // 2001 08 30 David Abrahams
@@ -41,8 +36,7 @@
 #include <utility> // needed for the assignment from pair to tuple
 
 #include "boost/type_traits/cv_traits.hpp"
-#include "boost/type_traits/function_traits.hpp"
-    
+							    
 namespace boost {
 namespace tuples {
 
@@ -51,18 +45,7 @@ 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;
-};
-
+  inline const null_type cnull_type() { return null_type(); }
 } // end detail
 
 // - cons forward declaration -----------------------------------------------
@@ -100,6 +83,41 @@ namespace detail {
 template<class T>
 class generate_error;
 
+// tuple default argument wrappers ---------------------------------------
+// Work for non-reference types, intentionally not for references
+template <class T>
+struct default_arg {
+
+// Non-class temporaries cannot have qualifiers.
+// To prevent f to return for example const int, we remove cv-qualifiers
+// from all temporaries. 
+     static typename boost::remove_cv<T>::type f() { return T(); }
+};
+
+// This is just to produce a more informative error message
+// The code would fail in any case
+template<class T, int N>
+struct default_arg<T[N]> {
+  static T* f() { 
+    return generate_error<T[N]>::arrays_are_not_valid_tuple_elements; }
+};
+   
+template <class T>
+struct default_arg<T&> {
+  static T& f() { 
+#ifndef __sgi
+    return generate_error<T>::no_default_values_for_reference_types;
+#else
+    // MIPSpro instantiates functions even when it should not, so
+    // this technique can not be used for error checking.
+    // The simple workaround is to just not have this error checking
+    // with MIPSpro.
+    static T x;
+    return x;
+#endif
+  }
+};
+
 // - cons getters --------------------------------------------------------
 // called: get_class<N>::get<RETURN_TYPE>(aTuple)
 
@@ -108,12 +126,12 @@ struct get_class {
   template<class RET, class HT, class TT >
   inline static RET get(const cons<HT, TT>& t)
   {
-    return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
+    return get_class<N-1>::template get<RET>(t.tail);
   }
   template<class RET, class HT, class TT >
   inline static RET get(cons<HT, TT>& t)
   {
-    return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
+    return get_class<N-1>::template get<RET>(t.tail);
   }
 };
 
@@ -153,21 +171,6 @@ 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:
-  typedef typename boost::add_const<unqualified_type>::type type;
-};
-template<class T>
-struct element<0,const T>
-{
-  typedef typename boost::add_const<typename T::head_type>::type type;
-};
-
 // -get function templates -----------------------------------------------
 // Usage: get<N>(aTuple)
 
@@ -182,7 +185,6 @@ template <class T> struct access_traits {
   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,
@@ -198,6 +200,7 @@ template <class T> struct access_traits<T&> {
   typedef T& parameter_type;   
 };
 
+
 // get function for non-const cons-lists, returns a reference to the element
 
 template<int N, class HT, class TT>
@@ -205,7 +208,7 @@ inline typename access_traits<
                   typename element<N, cons<HT, TT> >::type
                 >::non_const_type
 get(cons<HT, TT>& c BOOST_TUPLE_DUMMY_PARM) { 
-  return detail::get_class<N>::BOOST_NESTED_TEMPLATE 
+  return detail::get_class<N>::template 
          get<
            typename access_traits<
              typename element<N, cons<HT, TT> >::type
@@ -220,7 +223,7 @@ inline typename access_traits<
                   typename element<N, cons<HT, TT> >::type
                 >::const_type
 get(const cons<HT, TT>& c BOOST_TUPLE_DUMMY_PARM) { 
-  return detail::get_class<N>::BOOST_NESTED_TEMPLATE 
+  return detail::get_class<N>::template 
          get<
            typename access_traits<
              typename element<N, cons<HT, TT> >::type
@@ -228,28 +231,6 @@ get(const cons<HT, TT>& c BOOST_TUPLE_DUMMY_PARM) {
 } 
 
 // -- 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 {
@@ -257,33 +238,28 @@ 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;
+  head_type head;
   tail_type tail;
 
-  typename access_traits<stored_head_type>::non_const_type 
+  typename access_traits<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 
+  typename access_traits<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() {}
-
+  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,
+  cons(typename access_traits<head_type>::parameter_type h,
        const tail_type& t)
     : head (h), tail(t) {}  
 
@@ -292,18 +268,9 @@ struct cons {
   cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, 
         T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 ) 
     : head (t1), 
-      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
+      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull_type())
       {}
 
-  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) {}
 
@@ -347,26 +314,22 @@ 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;
+  head_type head;
  
-  typename access_traits<stored_head_type>::non_const_type 
+  typename access_traits<head_type>::non_const_type 
   get_head() { return head; }
   
   null_type get_tail() { return null_type(); }  
 
-  typename access_traits<stored_head_type>::const_type 
+  typename access_traits<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() : head(detail::default_arg<HT>::f()) {}
 
-  cons(typename access_traits<stored_head_type>::parameter_type h,
+  cons(typename access_traits<head_type>::parameter_type h,
        const null_type& = null_type())
     : head (h) {}  
 
@@ -376,12 +339,6 @@ struct cons<HT, 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) {}
   
@@ -395,7 +352,7 @@ struct cons<HT, null_type> {
 
   template <int N>
   typename access_traits<
-             typename element<N, self_type>::type
+             typename element<N, cons>::type
             >::non_const_type
   get(BOOST_TUPLE_SINGLE_DUMMY_PARM) {
     return boost::tuples::get<N>(*this);
@@ -403,7 +360,7 @@ struct cons<HT, null_type> {
 
   template <int N>
   typename access_traits<
-             typename element<N, self_type>::type
+             typename element<N, cons>::type
            >::const_type
   get(BOOST_TUPLE_SINGLE_DUMMY_PARM) const {
     return boost::tuples::get<N>(*this);
@@ -467,95 +424,29 @@ public:
 
 
 // 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) {}
+  explicit tuple(
+    typename access_traits<T0>::parameter_type t0 
+      = detail::default_arg<T0>::f(),
+    typename access_traits<T1>::parameter_type t1 
+      = detail::default_arg<T1>::f(),
+    typename access_traits<T2>::parameter_type t2 
+      = detail::default_arg<T2>::f(),
+    typename access_traits<T3>::parameter_type t3 
+      = detail::default_arg<T3>::f(),
+    typename access_traits<T4>::parameter_type t4 
+      = detail::default_arg<T4>::f(),
+    typename access_traits<T5>::parameter_type t5 
+      = detail::default_arg<T5>::f(),
+    typename access_traits<T6>::parameter_type t6 
+      = detail::default_arg<T6>::f(),
+    typename access_traits<T7>::parameter_type t7 
+      = detail::default_arg<T7>::f(),
+    typename access_traits<T8>::parameter_type t8 
+      = detail::default_arg<T8>::f(),
+    typename access_traits<T9>::parameter_type t9 
+      = detail::default_arg<T9>::f())
 
+        : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}
 
   template<class U1, class U2>
   tuple(const cons<U1, U2>& p) : inherited(p) {}
@@ -878,6 +769,6 @@ tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
 #undef BOOST_TUPLE_DUMMY_PARM
 #undef BOOST_TUPLE_SINGLE_DUMMY_PARM
 
-#endif // BOOST_TUPLE_BASIC_HPP
+#endif	// BOOST_TUPLE_BASIC_HPP
 
 

include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp

@@ -98,7 +98,6 @@ namespace tuples {
         }
       };
 
-    template <typename T> struct add_const_reference : add_reference<typename add_const<T>::type> {};
   } // end of namespace detail
 
     // cons builds a heterogenous list of types
@@ -109,42 +108,36 @@ namespace tuples {
      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; }  
+     typename boost::add_reference<head_type>::type get_head() { return head; }
+     typename boost::add_reference<tail_type>::type get_tail() { return tail; }  
 
-     head_cref get_head() const { return head; }
-     tail_cref get_tail() const { return tail; }
+     typename boost::add_reference<const head_type>::type get_head() const { return head; }
+     typename boost::add_reference<const tail_type>::type get_tail() const { return tail; }
   
 #if defined BOOST_MSVC
       template<typename Tail>
-      explicit cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
+      explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
                     const Tail& t) : head(h), tail(t.head, t.tail)
       {
       }
 
-      explicit cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
+      explicit cons(const head_type& 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) : 
+      explicit cons(const head_type& h, const T& t) : 
         head(h), tail(t.head, t.tail)
       {
       }
 
-      explicit cons(head_cref h = head_type(),
-                    tail_cref t = tail_type()) :
+      explicit cons(const head_type& h = head_type(),
+                    const tail_type& t = tail_type()) :
         head(h), tail(t)
       {
       }
@@ -253,58 +246,6 @@ namespace tuples {
 
     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
@@ -328,7 +269,6 @@ namespace tuples {
         typedef typename add_reference<const elt_type>::type RET;
         typedef RET type;
       };
-#endif // vc7
 
     } // namespace detail
 
@@ -423,31 +363,20 @@ namespace tuples {
       typedef typename mapped_tuple::cons2 cons2;
       typedef typename mapped_tuple::cons1 cons1;
 
-      typedef typename detail::add_const_reference<T1>::type t1_cref;
-      typedef typename detail::add_const_reference<T2>::type t2_cref;
-      typedef typename detail::add_const_reference<T3>::type t3_cref;
-      typedef typename detail::add_const_reference<T4>::type t4_cref;
-      typedef typename detail::add_const_reference<T5>::type t5_cref;
-      typedef typename detail::add_const_reference<T6>::type t6_cref;
-      typedef typename detail::add_const_reference<T7>::type t7_cref;
-      typedef typename detail::add_const_reference<T8>::type t8_cref;
-      typedef typename detail::add_const_reference<T9>::type t9_cref;
-      typedef typename detail::add_const_reference<T10>::type t10_cref;
     public:
       typedef cons1 inherited;
       typedef tuple self_type;
 
-      explicit tuple(t1_cref t1 = T1(), 
-                     t2_cref t2 = 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()
-          ) :
+      explicit tuple(const T1& t1 = T1(), 
+                     const T2& t2 = T2(),
+                     const T3& t3 = T3(),
+                     const T4& t4 = T4(),
+                     const T5& t5 = T5(),
+                     const T6& t6 = T6(),
+                     const T7& t7 = T7(),
+                     const T8& t8 = T8(),
+                     const T9& t9 = T9(),
+                     const T10& t10 = T10()) :
         cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10))))))))))
       {
       }
@@ -666,8 +595,8 @@ namespace tuples {
                         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<T6>(&t5),
+                        detail::assign_to_pointee<T5>(&t6));
     }
 
     // Tie variables into a tuple
@@ -766,9 +695,6 @@ namespace tuples {
     }
     // "ignore" allows tuple positions to be ignored when using "tie". 
     namespace {
-#if (defined(BOOST_MSVC) && BOOST_MSVC <= 1300) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590031)
-      static
-#endif 
       detail::swallow_assign ignore;
     }
 

include/boost/tuple/tuple.hpp

@@ -18,13 +18,6 @@
 #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"
 
@@ -39,7 +32,7 @@ namespace boost { namespace python { class tuple; }}
 
 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
-namespace boost {    
+namespace boost {				    
 
 using tuples::tuple;
 using tuples::make_tuple;
@@ -92,4 +85,4 @@ get(const tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0
 } // end namespace boost
 
 
-#endif // BOOST_TUPLE_HPP
+#endif	// BOOST_TUPLE_HPP

include/boost/tuple/tuple_comparison.hpp

@@ -69,7 +69,7 @@ inline bool neq(const T1& lhs, const T2& rhs) {
          neq(lhs.get_tail(), rhs.get_tail());
 }
 template<>
-inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return false; }
+inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return true; }
 
 template<class T1, class T2>
 inline bool lt(const T1& lhs, const T2& rhs) {
@@ -177,4 +177,4 @@ inline bool operator>=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
 } // end of namespace boost
 
 
-#endif // BOOST_TUPLE_COMPARISON_HPP
+#endif	// BOOST_TUPLE_COMPARISON_HPP

include/boost/tuple/tuple_io.hpp

@@ -25,7 +25,7 @@
 #   if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97) 
 #define BOOST_NO_TEMPLATED_STREAMS
 #endif
-#endif // __GNUC__
+#endif	// __GNUC__
 
 #if defined BOOST_NO_TEMPLATED_STREAMS
 #include <iostream>
@@ -36,23 +36,8 @@
 
 #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 {
 
@@ -86,9 +71,9 @@ public:
      // 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;
+         case open : c = '('; break;					    
+         case close : c = ')'; break;					    
+         case delimiter : c = ' '; break;
        }
      }
      return c;
@@ -109,9 +94,9 @@ public:
      // 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;
+         case open :  c = i.widen('('); break;					    
+         case close : c = i.widen(')'); break;					    
+         case delimiter : c = i.widen(' '); break;
        }
      }
      return c;
@@ -127,7 +112,7 @@ public:
      // convertible long.
       i.iword(get_stream_index(m)) = static_cast<long>(c);
    }
-#endif // BOOST_NO_TEMPLATED_STREAMS
+#endif	// BOOST_NO_TEMPLATED_STREAMS
 };
 
 } // end of namespace detail
@@ -156,8 +141,8 @@ public:
   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
+#endif	// BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif	// BOOST_NO_TEMPLATED_STREAMS
 };
 
 #if defined (BOOST_NO_TEMPLATED_STREAMS)
@@ -227,7 +212,7 @@ template<class T1>
 inline std::ostream& print(std::ostream& o, const cons<T1, null_type>& t) {
   return o << t.head;
 }
-#endif // BOOST_NO_TEMPLATED_STREAMS
+#endif	// BOOST_NO_TEMPLATED_STREAMS
  
 inline std::ostream& print(std::ostream& o, const null_type&) { return o; }
 
@@ -241,7 +226,7 @@ print(std::ostream& o, const cons<T1, T2>& t) {
 
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   if (tuples::length<T2>::value == 0)
-    return o;
+	return o;
 #endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   o << d;
   
@@ -278,14 +263,14 @@ print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, T2>& t) {
 
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   if (tuples::length<T2>::value == 0)
-    return o;
+	return o;
 #endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   o << d;
 
   return print(o, t.tail);
 }
 
-#endif  // BOOST_NO_TEMPLATED_STREAMS
+#endif	// BOOST_NO_TEMPLATED_STREAMS
 
 } // namespace detail
 
@@ -329,7 +314,7 @@ operator<<(std::basic_ostream<CharType, CharTrait>& o,
 
   return o;
 }
-#endif // BOOST_NO_TEMPLATED_STREAMS
+#endif	// BOOST_NO_TEMPLATED_STREAMS
 
    
 // -------------------------------------------------------------
@@ -345,11 +330,7 @@ extract_and_check_delimiter(
 {
   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
+  const bool is_delimiter = (!isspace(d) );      
 
   char c;
   if (is_delimiter) { 
@@ -376,7 +357,7 @@ read (std::istream &is, cons<T1, null_type>& t1) {
 }
 #else
 inline std::istream& read(std::istream& i, const null_type&) { return i; }
-#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif	// !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    
 template<class T1, class T2>
 inline std::istream& 
@@ -388,7 +369,7 @@ read(std::istream &is, cons<T1, T2>& t1) {
 
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   if (tuples::length<T2>::value == 0)
-    return is;
+	return is;
 #endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
   extract_and_check_delimiter(is, format_info::delimiter);
@@ -436,14 +417,7 @@ extract_and_check_delimiter(
 {
   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
+  const bool is_delimiter = (!isspace(d) );      
 
   CharType c;
   if (is_delimiter) { 
@@ -470,7 +444,7 @@ template<class CharType, class CharTrait>
 inline std::basic_istream<CharType, CharTrait>& 
 read(std::basic_istream<CharType, CharTrait>& i, const null_type&) { return i; }
 
-#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif	// !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 template<class CharType, class CharTrait, class T1, class T2>
 inline std::basic_istream<CharType, CharTrait>& 
@@ -482,7 +456,7 @@ read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) {
 
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   if (tuples::length<T2>::value == 0)
-    return is;
+	return is;
 #endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
   extract_and_check_delimiter(is, format_info::delimiter);
@@ -520,11 +494,11 @@ operator>>(std::basic_istream<CharType, CharTrait>& is, cons<T1, T2>& t1) {
   return is;
 }
 
-#endif // BOOST_NO_TEMPLATED_STREAMS
+#endif	// BOOST_NO_TEMPLATED_STREAMS
 
 } // end of namespace tuples
 } // end of namespace boost
 
-#endif // BOOST_TUPLE_IO_HPP
+#endif	// BOOST_TUPLE_IO_HPP
 
 

index.html

@@ -1,8 +0,0 @@
-<html>
-<head>
-<meta http-equiv="refresh" content="0; URL=doc/tuple_users_guide.html">
-</head>
-<body>
-Automatic redirection failed, please go to <a href="doc/tuple_users_guide.html">doc/tuple_users_guide.html</a>
-</body>
-</html>

test/Jamfile

@@ -1,20 +0,0 @@
-subproject libs/tuple/test ;
-
-unit-test tuple_test_bench
-    : tuple_test_bench.cpp
-      <lib>../../test/build/test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-
-unit-test io_test
-    : io_test.cpp
-      <lib>../../test/build/test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-
-unit-test another_tuple_test_bench
-    : another_tuple_test_bench.cpp
-      <lib>../../test/build/test_exec_monitor
-    : <sysinclude>$(BOOST_ROOT)
-    ;
-

test/another_tuple_test_bench.cpp

@@ -1,17 +1,3 @@
-// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-
 //  another_test_bench.cpp  --------------------------------
 
 // This file has various tests to see that things that shouldn't
@@ -108,7 +94,7 @@ void foo4()
   A a;
   tuple<int, double&, const A&> t(1, d, a);
   const tuple<int, double&, const A> ct = t;
-  (void)ct;
+
 #ifdef E8
   get<0>(ct) = 5; // can't assign to const
 #endif
@@ -133,10 +119,9 @@ void foo4()
 
   void foo5() {
     tuple<char, BB*, BB, DD> t;
-    (void)t;
+
     tuple<char, char> aaa;
     tuple<int, int> bbb(aaa);
-    (void)bbb;
     //    tuple<int, AA*, CC, CC> a = t;
     //    a = t;
   }

test/io_test.cpp

@@ -1,16 +1,3 @@
-// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
 // -- io_test.cpp -----------------------------------------------
 //
 // Testing the I/O facilities of tuples
@@ -32,6 +19,8 @@
 #include <sstream>
 #endif
 
+#include "boost/config.hpp"
+
 using namespace std;
 using namespace boost;
 
@@ -44,8 +33,7 @@ typedef istringstream useThisIStringStream;
 #endif
 
 int test_main(int argc, char * argv[] ) {
-   (void)argc;
-   (void)argv;
+
    using boost::tuples::set_close;
    using boost::tuples::set_open;
    using boost::tuples::set_delimiter;
@@ -87,7 +75,7 @@ int test_main(int argc, char * argv[] ) {
   
   // When teading tuples from a stream, manipulators must be set correctly:
   ifstream tmp3("temp.tmp");
-  tuple<string, string, int> j;
+  tuple<string, string, int> j;		    
 
 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   tmp3 >> j; 
@@ -106,7 +94,7 @@ int test_main(int argc, char * argv[] ) {
   useThisIStringStream is("(100 200 300)"); 
    
   tuple<int, int, int> ti; 
-  BOOST_TEST(bool(is >> ti));
+  BOOST_TEST(is >> ti);
   BOOST_TEST(ti == make_tuple(100, 200, 300));
    
 

test/tuple_test_bench.cpp

@@ -1,16 +1,3 @@
-// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
 //  tuple_test_bench.cpp  --------------------------------
 
 #define BOOST_INCLUDE_MAIN  // for testing, include rather than link
@@ -199,7 +186,7 @@ void element_access_test()
 
   double e = get<1>(t);
   BOOST_TEST(e > 2.69 && e < 2.71);
-     
+	     
   get<1>(t) = 3.14+i;
   BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
 
@@ -227,7 +214,7 @@ void element_access_test()
 
   double e = get<1>(t);
   BOOST_TEST(e > 2.69 && e < 2.71);
-     
+	     
   get<1>(t) = 3.14+i;
   BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
 
@@ -310,7 +297,7 @@ make_tuple_test()
 
 
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-    A a = A(); B b;
+    A a; B b;
     const A ca = a;
     make_tuple(cref(a), b);
     make_tuple(ref(a), b);
@@ -321,7 +308,7 @@ make_tuple_test()
      
 // the result of make_tuple is assignable:
    BOOST_TEST(make_tuple(2, 4, 6) == 
-             (make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));
+	     (make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));
 
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
     make_tuple("Donald", "Daisy"); // should work;
@@ -408,7 +395,6 @@ equality_test()
   tuple<int, char> t4(2, 'a');
   BOOST_TEST(t1 != t3);
   BOOST_TEST(t1 != t4);
-  BOOST_TEST(!(t1 != t2));
 }