This commit was manufactured by cvs2svn to create tag

'Version_1_26_0'.

[SVN r11842]

doc/tuple_users_guide.html

@@ -63,6 +63,7 @@ To compensate for this "deficiency", the Boost Tuple Library implement
 <p>To use tuple input and output operators,
 
 <pre><code>#include &quot;boost/tuple/tuple_io.hpp&quot;</code></pre>
+and add the <code>libs/tuple/src/tuple.hpp</code> file to your project.
 
 Both <code>tuple_io.hpp</code> and <code>tuple_comparison.hpp</code> include <code>tuple.hpp</code>.
 
@@ -74,14 +75,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.
+The data element can be any C++ type, except for a non-reference type
-Note that <code>void</code> and plain function types are valid 
+that is not copy constructible from a const qualified reference to that
-C++ types, but objects of such types cannot exist. 
+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.)
-Hence, if a tuple type contains such types as elements, the tuple type
+</p>
-can exist, but not an object of that type.
+
-There are natural limitations for element types that cannot
+<p>
-be be copied, or that are not default constructible (see 'Constructing tuples'
+Examples of types that are not allowed as tuple elements:
- below). 
+
+<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,6 +102,21 @@ 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>
@@ -133,31 +157,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>
 
@@ -492,10 +491,11 @@ Below is a list of compilers and known problems with each compiler:
 </table>
 
 <h2><a name = "thanks">Acknowledgements</a></h2>
-Gary Powell has been an indispensable helping hand. In particular, stream manipulators for tuples were his idea. Doug Gregor came up with a working version for MSVC. Thanks to Jeremy Siek, William Kempf and Jens Maurer for their help and suggestions. 
+Gary Powell has been an indispensable helping hand. In particular, stream manipulators for tuples were his idea. Doug Gregor came up with a working version for MSVC. Thanks to Jeremy Siek, William Kempf, Jens Maurer for their help and suggestions. 
-The comments by Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes, David Abrahams and Hartmut Kaiser helped to improve the
+The comments by Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes and David Abrahams helped to improve the
 library.
 The idea for the tie mechanism came from an old usenet article by Ian McCulloch, where he proposed something similar for std::pairs.
+
 <h2><a name = "references">References</a></h2>
 
 <p>

include/boost/tuple/detail/tuple_basic.hpp

@@ -23,11 +23,6 @@
 // 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(); }
+  inline const null_type cnull_type() { 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 -----------------------------------------------
@@ -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)
 
@@ -167,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,
@@ -183,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>
@@ -213,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 {
@@ -242,33 +238,28 @@ struct cons {
   typedef HT head_type;
   typedef TT tail_type;
 
-  typedef typename 
+  head_type head;
-    detail::wrap_non_storeable_type<head_type>::type stored_head_type;
-
-  stored_head_type head;
   tail_type tail;
 
-  typename access_traits<stored_head_type>::non_const_type 
+  typename access_traits<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) {}  
 
@@ -277,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) {}
 
@@ -333,24 +315,21 @@ struct cons<HT, null_type> {
   typedef HT head_type;
   typedef null_type tail_type;
 
-  typedef typename 
+  head_type head;
-    detail::wrap_non_storeable_type<head_type>::type stored_head_type;
-  stored_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(detail::default_arg<HT>::f()) {}
-  cons() : head() {}
 
-  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) {}  
 
@@ -360,12 +339,6 @@ struct cons<HT, null_type> {
        const null_type&, const null_type&, const null_type&)
   : head (t1) {}
 
-  cons(const null_type& t1, 
-       const null_type&, const null_type&, const null_type&, 
-       const null_type&, const null_type&, const null_type&, 
-       const null_type&, const null_type&, const null_type&)
-  : head () {}
-
   template <class HT2>
   cons( const cons<HT2, null_type>& u ) : head(u.head) {}
   
@@ -451,95 +424,29 @@ public:
 
 
 // access_traits<T>::parameter_type takes non-reference types as const T& 
-  tuple() {}
+  explicit tuple(
-  
+    typename access_traits<T0>::parameter_type t0 
-  tuple(typename access_traits<T0>::parameter_type t0)
+      = detail::default_arg<T0>::f(),
-    : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(), 
+    typename access_traits<T1>::parameter_type t1 
-                detail::cnull(), detail::cnull(), detail::cnull(), 
+      = detail::default_arg<T1>::f(),
-                detail::cnull(), detail::cnull(), detail::cnull()) {}
+    typename access_traits<T2>::parameter_type t2 
-
+      = detail::default_arg<T2>::f(),
-  tuple(typename access_traits<T0>::parameter_type t0,
+    typename access_traits<T3>::parameter_type t3 
-        typename access_traits<T1>::parameter_type t1)
+      = detail::default_arg<T3>::f(),
-    : inherited(t0, t1, detail::cnull(), detail::cnull(), 
+    typename access_traits<T4>::parameter_type t4 
-                detail::cnull(), detail::cnull(), detail::cnull(), 
+      = detail::default_arg<T4>::f(),
-                detail::cnull(), detail::cnull(), detail::cnull()) {}
+    typename access_traits<T5>::parameter_type t5 
-
+      = detail::default_arg<T5>::f(),
-  tuple(typename access_traits<T0>::parameter_type t0,
+    typename access_traits<T6>::parameter_type t6 
-        typename access_traits<T1>::parameter_type t1,
+      = detail::default_arg<T6>::f(),
-        typename access_traits<T2>::parameter_type t2)
+    typename access_traits<T7>::parameter_type t7 
-    : inherited(t0, t1, t2, detail::cnull(), detail::cnull(), 
+      = detail::default_arg<T7>::f(),
-                detail::cnull(), detail::cnull(), detail::cnull(), 
+    typename access_traits<T8>::parameter_type t8 
-                detail::cnull(), detail::cnull()) {}
+      = detail::default_arg<T8>::f(),
-
+    typename access_traits<T9>::parameter_type t9 
-  tuple(typename access_traits<T0>::parameter_type t0,
+      = detail::default_arg<T9>::f())
-        typename access_traits<T1>::parameter_type t1,
-        typename access_traits<T2>::parameter_type t2,
-        typename access_traits<T3>::parameter_type t3)
-    : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(), 
-                detail::cnull(), detail::cnull(), detail::cnull(), 
-                detail::cnull()) {}
-
-  tuple(typename access_traits<T0>::parameter_type t0,
-        typename access_traits<T1>::parameter_type t1,
-        typename access_traits<T2>::parameter_type t2,
-        typename access_traits<T3>::parameter_type t3,
-        typename access_traits<T4>::parameter_type t4)
-    : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(), 
-                detail::cnull(), detail::cnull(), detail::cnull()) {}
-
-  tuple(typename access_traits<T0>::parameter_type t0,
-        typename access_traits<T1>::parameter_type t1,
-        typename access_traits<T2>::parameter_type t2,
-        typename access_traits<T3>::parameter_type t3,
-        typename access_traits<T4>::parameter_type t4,
-        typename access_traits<T5>::parameter_type t5)
-    : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(), 
-                detail::cnull(), detail::cnull()) {}
-
-  tuple(typename access_traits<T0>::parameter_type t0,
-        typename access_traits<T1>::parameter_type t1,
-        typename access_traits<T2>::parameter_type t2,
-        typename access_traits<T3>::parameter_type t3,
-        typename access_traits<T4>::parameter_type t4,
-        typename access_traits<T5>::parameter_type t5,
-        typename access_traits<T6>::parameter_type t6)
-    : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(), 
-                detail::cnull(), detail::cnull()) {}
-
-  tuple(typename access_traits<T0>::parameter_type t0,
-        typename access_traits<T1>::parameter_type t1,
-        typename access_traits<T2>::parameter_type t2,
-        typename access_traits<T3>::parameter_type t3,
-        typename access_traits<T4>::parameter_type t4,
-        typename access_traits<T5>::parameter_type t5,
-        typename access_traits<T6>::parameter_type t6,
-        typename access_traits<T7>::parameter_type t7)
-    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(), 
-                detail::cnull()) {}
-
-  tuple(typename access_traits<T0>::parameter_type t0,
-        typename access_traits<T1>::parameter_type t1,
-        typename access_traits<T2>::parameter_type t2,
-        typename access_traits<T3>::parameter_type t3,
-        typename access_traits<T4>::parameter_type t4,
-        typename access_traits<T5>::parameter_type t5,
-        typename access_traits<T6>::parameter_type t6,
-        typename access_traits<T7>::parameter_type t7,
-        typename access_traits<T8>::parameter_type t8)
-    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, detail::cnull()) {}
-
-  tuple(typename access_traits<T0>::parameter_type t0,
-        typename access_traits<T1>::parameter_type t1,
-        typename access_traits<T2>::parameter_type t2,
-        typename access_traits<T3>::parameter_type t3,
-        typename access_traits<T4>::parameter_type t4,
-        typename access_traits<T5>::parameter_type t5,
-        typename access_traits<T6>::parameter_type t6,
-        typename access_traits<T7>::parameter_type t7,
-        typename access_traits<T8>::parameter_type t8,
-        typename access_traits<T9>::parameter_type t9)
-    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}
 
+        : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}
 
   template<class U1, class U2>
   tuple(const cons<U1, U2>& p) : inherited(p) {}
@@ -862,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

@@ -246,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
@@ -321,7 +269,6 @@ namespace tuples {
         typedef typename add_reference<const elt_type>::type RET;
         typedef RET type;
       };
-#endif // vc7
 
     } // namespace detail
 
@@ -417,7 +364,6 @@ namespace tuples {
       typedef typename mapped_tuple::cons1 cons1;
 
     public:
-      typedef cons1 inherited;
       typedef tuple self_type;
 
       explicit tuple(const T1& t1 = T1(), 
@@ -648,8 +594,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>(&t5),
-                        detail::assign_to_pointee<T6>(&t6));
+                        detail::assign_to_pointee<T5>(&t6));
     }
 
     // Tie variables into a tuple

include/boost/tuple/tuple.hpp

@@ -32,57 +32,14 @@
 
 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
-namespace boost {    
+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
+#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,6 +36,8 @@
 
 #include "boost/tuple/tuple.hpp"
 
+
+				    
 namespace boost {
 namespace tuples {
 
@@ -43,19 +45,11 @@ 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];
-   {
-     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();   
 
@@ -64,13 +58,13 @@ public:
 
 #if defined (BOOST_NO_TEMPLATED_STREAMS)
    static char get_manipulator(std::ios& i, manipulator_type m) {
-     char c = static_cast<char>(i.iword(get_stream_index(m))); 
+     char c = static_cast<char>(i.iword(stream_index[m])); 
      
      // parentheses and space are the default manipulators
      if (!c) {
        switch(m) {
-         case open : c = '('; break;
+         case open : c = '('; break;					    
-         case close : c = ')'; break;
+         case close : c = ')'; break;					    
          case delimiter : c = ' '; break;
        }
      }
@@ -78,7 +72,7 @@ public:
    }
 
    static void set_manipulator(std::ios& i, manipulator_type m, char c) {
-      i.iword(get_stream_index(m)) = static_cast<long>(c);
+      i.iword(stream_index[m]) = static_cast<long>(c);
    }
 #else
    template<class CharType, class CharTrait>
@@ -88,12 +82,12 @@ public:
      // A valid instanitation of basic_stream allows CharType to be any POD,
      // hence, the static_cast may fail (it fails if long is not convertible 
      // to CharType
-     CharType c = static_cast<CharType>(i.iword(get_stream_index(m)) ); 
+     CharType c = static_cast<CharType>(i.iword(stream_index[m]) ); 
      // parentheses and space are the default manipulators
      if (!c) {
        switch(m) {
-         case open :  c = i.widen('('); break;
+         case open :  c = i.widen('('); break;					    
-         case close : c = i.widen(')'); break;
+         case close : c = i.widen(')'); break;					    
          case delimiter : c = i.widen(' '); break;
        }
      }
@@ -108,9 +102,9 @@ public:
      // A valid instanitation of basic_stream allows CharType to be any POD,
      // hence, the static_cast may fail (it fails if CharType is not 
      // convertible long.
-      i.iword(get_stream_index(m)) = static_cast<long>(c);
+      i.iword(stream_index[m]) = static_cast<long>(c);
    }
-#endif // BOOST_NO_TEMPLATED_STREAMS
+#endif	// BOOST_NO_TEMPLATED_STREAMS
 };
 
 } // end of namespace detail
@@ -139,8 +133,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_TEMPLATE_PARTIAL_SPECIALIZATION
-#endif // BOOST_NO_TEMPLATED_STREAMS
+#endif	// BOOST_NO_TEMPLATED_STREAMS
 };
 
 #if defined (BOOST_NO_TEMPLATED_STREAMS)
@@ -210,7 +204,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; }
 
@@ -224,7 +218,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;
   
@@ -261,14 +255,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
 
@@ -312,7 +306,7 @@ operator<<(std::basic_ostream<CharType, CharTrait>& o,
 
   return o;
 }
-#endif // BOOST_NO_TEMPLATED_STREAMS
+#endif	// BOOST_NO_TEMPLATED_STREAMS
 
    
 // -------------------------------------------------------------
@@ -355,7 +349,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& 
@@ -367,7 +361,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);
@@ -442,7 +436,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>& 
@@ -454,7 +448,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);
@@ -492,11 +486,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
 
 

src/tuple.cpp

@@ -0,0 +1,34 @@
+//  tuple.cpp -----------------------------------------------------
+
+// Copyright (C) 1999, 2000, 2001 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
+//
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies. 
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice 
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty, 
+// and with no claim as to its suitability for any purpose.
+
+// For more information, see http://lambda.cs.utu.fi 
+
+// Revision History 
+
+// 16 02 01 Initial Version (GWP)
+// ----------------------------------------------------------------- 
+
+#include "boost/tuple/tuple_io.hpp"
+
+namespace boost {
+namespace tuples {
+namespace detail {
+   
+const int
+ format_info::stream_index[number_of_manipulators] 
+   = { std::ios::xalloc(), std::ios::xalloc(), std::ios::xalloc() };
+   
+} // namespace detail
+} // namespace tuples   
+} // namespace boost

test/README

@@ -8,9 +8,7 @@ For example, in libs/tuple/test directory you would type (using g++):
 
 g++ -I../../.. tuple_test_bench.cpp
 
-The following is not true anymore:
+If you want to use tuple_io, you need to compile and link src/tuple.cpp:
 
-  If you want to use tuple_io, you need to compile and link src/tuple.cpp:
+g++ -I../../.. ../src/tuple.cpp io_test.cpp
-  g++ -I../../.. ../src/tuple.cpp io_test.cpp
 
-Thanks to Hartmut Kaiser's suggestion, the tuple.cpp is not needed anymore.

test/io_test.cpp

@@ -75,7 +75,7 @@ int test_main(int argc, char * argv[] ) {
   
   // When teading tuples from a stream, manipulators must be set correctly:
   ifstream tmp3("temp.tmp");
-  tuple<string, string, int> j;
+  tuple<string, string, int> j;		    
 
 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   tmp3 >> j; 

test/tuple_test_bench.cpp

@@ -97,42 +97,42 @@ tuple<char(&)[10]> v2(cs);  // ok
 void
 construction_test()
 {
-
+ 
   // Note, the get function can be called without the tuples:: qualifier,
   // as it is lifted to namespace boost with a "using tuples::get" but
   // MSVC 6.0 just cannot find get without the namespace qualifier
 
-  tuple<int> t1;
+  tuple<int> t1; 
-  BOOST_TEST(get<0>(t1) == int());
+  BOOST_TEST(tuples::get<0>(t1) == int());
-
+  
   tuple<float> t2(5.5f);
-  BOOST_TEST(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f);
+  BOOST_TEST(tuples::get<0>(t2) > 5.4f && tuples::get<0>(t2) < 5.6f);
 
   tuple<foo> t3(foo(12));
-  BOOST_TEST(get<0>(t3) == foo(12));
+  BOOST_TEST(tuples::get<0>(t3) == foo(12));
 
   tuple<double> t4(t2);
-  BOOST_TEST(get<0>(t4) > 5.4 && get<0>(t4) < 5.6);
+  BOOST_TEST(tuples::get<0>(t4) > 5.4 && tuples::get<0>(t4) < 5.6);
 
   tuple<int, float> t5;
-  BOOST_TEST(get<0>(t5) == int());
+  BOOST_TEST(tuples::get<0>(t5) == int());
-  BOOST_TEST(get<1>(t5) == float());
+  BOOST_TEST(tuples::get<1>(t5) == float());
 
   tuple<int, float> t6(12, 5.5f);
-  BOOST_TEST(get<0>(t6) == 12);
+  BOOST_TEST(tuples::get<0>(t6) == 12);
-  BOOST_TEST(get<1>(t6) > 5.4f && get<1>(t6) < 5.6f);
+  BOOST_TEST(tuples::get<1>(t6) > 5.4f && tuples::get<1>(t6) < 5.6f);
 
   tuple<int, float> t7(t6);
-  BOOST_TEST(get<0>(t7) == 12);
+  BOOST_TEST(tuples::get<0>(t7) == 12);
-  BOOST_TEST(get<1>(t7) > 5.4f && get<1>(t7) < 5.6f);
+  BOOST_TEST(tuples::get<1>(t7) > 5.4f && tuples::get<1>(t7) < 5.6f);
 
   tuple<long, double> t8(t6);
-  BOOST_TEST(get<0>(t8) == 12);
+  BOOST_TEST(tuples::get<0>(t8) == 12);
-  BOOST_TEST(get<1>(t8) > 5.4f && get<1>(t8) < 5.6f);
+  BOOST_TEST(tuples::get<1>(t8) > 5.4f && tuples::get<1>(t8) < 5.6f);
 
-  dummy(
+  dummy( 
     tuple<no_def_constructor, no_def_constructor, no_def_constructor>(
-       std::string("Jaba"),   // ok, since the default
+       std::string("Jaba"),   // ok, since the default 
        std::string("Daba"),   // constructor is not used
        std::string("Doo")
     )
@@ -141,7 +141,7 @@ construction_test()
 // testing default values
   dummy(tuple<int, double>());
   dummy(tuple<int, double>(1));
-  dummy(tuple<int, double>(1,3.14));
+  dummy(tuple<int, double>(1,3.14)); 
 
 
   //  dummy(tuple<double&>()); // should fail, not defaults for references
@@ -154,8 +154,9 @@ construction_test()
   dummy(tuple<const double&>(dd+3.14)); // ok, but dangerous
 #endif
 
-  //  dummy(tuple<double&>(dd+3.14)); // should fail,
+  //  dummy(tuple<double&>(dd+3.14)); // should fail, 
   //                                  // temporary to non-const reference
+
 }
 
 
@@ -163,38 +164,38 @@ construction_test()
 // - testing element access ---------------------------------------------------
 // ----------------------------------------------------------------------------
 
-void element_access_test()
+void element_access_test() 
 {
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  double d = 2.7;
+  double d = 2.7; 
   A a;
   tuple<int, double&, const A&, int> t(1, d, a, 2);
   const tuple<int, double&, const A, int> ct = t;
 
-  int i  = get<0>(t);
+  int i  = tuples::get<0>(t);
-  int i2 = get<3>(t);
+  int i2 = tuples::get<3>(t);
 
   BOOST_TEST(i == 1 && i2 == 2);
 
-  int j  = get<0>(ct);
+  int j  = tuples::get<0>(ct);
   BOOST_TEST(j == 1);
    
-  get<0>(t) = 5;
+  tuples::get<0>(t) = 5;
   BOOST_TEST(t.head == 5);
    
-  //  get<0>(ct) = 5; // can't assign to const
+  //  tuples::get<0>(ct) = 5; // can't assign to const
 
-  double e = get<1>(t);
+  double e = tuples::get<1>(t);
   BOOST_TEST(e > 2.69 && e < 2.71);
-     
+	     
-  get<1>(t) = 3.14+i;
+  tuples::get<1>(t) = 3.14+i;
-  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
+  BOOST_TEST(tuples::get<1>(t) > 4.13 && tuples::get<1>(t) < 4.15);
 
-  //  get<4>(t) = A(); // can't assign to const
+  //  tuples::get<4>(t) = A(); // can't assign to const
-  //  dummy(get<5>(ct)); // illegal index
+  //  dummy(tuples::get<5>(ct)); // illegal index
 
-  ++get<0>(t);
+  ++tuples::get<0>(t);
-  BOOST_TEST(get<0>(t) == 6);
+  BOOST_TEST(tuples::get<0>(t) == 6);
 
   dummy(i); dummy(i2); dummy(j); dummy(e); // avoid warns for unused variables
 #else
@@ -202,27 +203,27 @@ void element_access_test()
   A a;
   tuple<int, double, const A, int> t(1, d, a, 2);
 
-  int i  = get<0>(t);
+  int i  = tuples::get<0>(t);
-  int i2 = get<3>(t);
+  int i2 = tuples::get<3>(t);
 
   BOOST_TEST(i == 1 && i2 == 2);
    
-  get<0>(t) = 5;
+  tuples::get<0>(t) = 5;
   BOOST_TEST(t.head == 5);
    
-  //  get<0>(ct) = 5; // can't assign to const
+  //  tuples::get<0>(ct) = 5; // can't assign to const
 
-  double e = get<1>(t);
+  double e = tuples::get<1>(t);
   BOOST_TEST(e > 2.69 && e < 2.71);
-     
+	     
-  get<1>(t) = 3.14+i;
+  tuples::get<1>(t) = 3.14+i;
-  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
+  BOOST_TEST(tuples::get<1>(t) > 4.13 && tuples::get<1>(t) < 4.15);
 
-  //  get<4>(t) = A(); // can't assign to const
+  //  tuples::get<4>(t) = A(); // can't assign to const
-  //  dummy(get<5>(ct)); // illegal index
+  //  dummy(tuples::get<5>(ct)); // illegal index
 
-  ++get<0>(t);
+  ++tuples::get<0>(t);
-  BOOST_TEST(get<0>(t) == 6);
+  BOOST_TEST(tuples::get<0>(t) == 6);
 
   dummy(i); dummy(i2); dummy(e); // avoid warns for unused variables
 #endif
@@ -241,13 +242,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(tuples::get<0>(t1) == tuples::get<0>(t2));
-  BOOST_TEST(get<1>(t1) == get<1>(t2));
+  BOOST_TEST(tuples::get<1>(t1) == tuples::get<1>(t2));
 
   tuple<long, std::string> t3(2, "a");
   t3 = t1;
-  BOOST_TEST((double)get<0>(t1) == get<0>(t3));
+  BOOST_TEST((double)tuples::get<0>(t1) == tuples::get<0>(t3));
-  BOOST_TEST(get<1>(t1) == get<1>(t3)[0]);
+  BOOST_TEST(tuples::get<1>(t1) == tuples::get<1>(t3)[0]);
 
 // testing copy and assignment with implicit conversions between elements
 // testing tie
@@ -268,15 +269,15 @@ void
 mutate_test()
 {
   tuple<int, float, bool, foo> t1(5, 12.2f, true, foo(4));
-  get<0>(t1) = 6;
+  tuples::get<0>(t1) = 6;
-  get<1>(t1) = 2.2f;
+  tuples::get<1>(t1) = 2.2f;
-  get<2>(t1) = false;
+  tuples::get<2>(t1) = false;
-  get<3>(t1) = foo(5);
+  tuples::get<3>(t1) = foo(5);
 
-  BOOST_TEST(get<0>(t1) == 6);
+  BOOST_TEST(tuples::get<0>(t1) == 6);
-  BOOST_TEST(get<1>(t1) > 2.1f && get<1>(t1) < 2.3f);
+  BOOST_TEST(tuples::get<1>(t1) > 2.1f && tuples::get<1>(t1) < 2.3f);
-  BOOST_TEST(get<2>(t1) == false);
+  BOOST_TEST(tuples::get<2>(t1) == false);
-  BOOST_TEST(get<3>(t1) == foo(5));
+  BOOST_TEST(tuples::get<3>(t1) == foo(5));
 }
 
 // ----------------------------------------------------------------------------
@@ -287,13 +288,13 @@ void
 make_tuple_test()
 {
   tuple<int, char> t1 = make_tuple(5, 'a');
-  BOOST_TEST(get<0>(t1) == 5);
+  BOOST_TEST(tuples::get<0>(t1) == 5);
-  BOOST_TEST(get<1>(t1) == 'a');
+  BOOST_TEST(tuples::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(tuples::get<0>(t2) == 2);
-  BOOST_TEST(get<1>(t2) == "Hi");
+  BOOST_TEST(tuples::get<1>(t2) == "Hi");
 
 
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
@@ -308,7 +309,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;
@@ -395,7 +396,6 @@ equality_test()
   tuple<int, char> t4(2, 'a');
   BOOST_TEST(t1 != t3);
   BOOST_TEST(t1 != t4);
-  BOOST_TEST(!(t1 != t2));
 }
 
 
@@ -447,8 +447,8 @@ void cons_test()
 void const_tuple_test()
 {
   const tuple<int, float> t1(5, 3.3f);
-  BOOST_TEST(get<0>(t1) == 5);
+  BOOST_TEST(tuples::get<0>(t1) == 5);
-  BOOST_TEST(get<1>(t1) == 3.3f);
+  BOOST_TEST(tuples::get<1>(t1) == 3.3f);
 }
 
 // ----------------------------------------------------------------------------
@@ -491,10 +491,3 @@ int test_main(int, char *[]) {
   tuple_length_test();
   return 0;
 }
-
-
-
-
-
-
-