This commit was manufactured by cvs2svn to create branch

'thread_rewrite'.

[SVN r30953]

include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp

@@ -1,32 +1,27 @@
 // - tuple_basic_no_partial_spec.hpp -----------------------------------------
 
 // Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2001 Doug Gregor (gregod@rpi.edu)
+// Copyright (C) 2001 Douglas Gregor (gregod@rpi.edu)
 // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
 //
-// Permission to copy, use, sell and distribute this software is granted
-// 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.
+// 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 
+// For more information, see http://www.boost.org or http://lambda.cs.utu.fi
 
-// Revision History 
+// Revision History
 //  14 02 01    Remove extra ';'. Also, fixed 10-parameter to make_tuple. (DG)
 //  10 02 01    Fixed "null_type" constructors.
 //              Implemented comparison operators globally.
 //              Hide element_type_ref and element_type_const_ref.
 //              (DG).
-//  09 02 01    Extended to tuples of length 10. Changed comparison for 
+//  09 02 01    Extended to tuples of length 10. Changed comparison for
 //              operator<()
 //              to the same used by std::pair<>, added cnull_type() (GP)
 //  03 02 01    Initial Version from original tuple.hpp code by JJ. (DG)
 
-// ----------------------------------------------------------------- 
+// -----------------------------------------------------------------
 
 #ifndef BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
 #define BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
@@ -44,15 +39,34 @@ namespace boost {
 namespace tuples {
 
     // null_type denotes the end of a list built with "cons"
-    struct null_type 
+    struct null_type
     {
       null_type() {}
       null_type(const null_type&, const null_type&) {}
     };
-     
+
     // a helper function to provide a const null_type type temporary
     inline const null_type cnull_type() { return null_type(); }
 
+// forward declaration of tuple
+    template<
+      typename T1 = null_type,
+      typename T2 = null_type,
+      typename T3 = null_type,
+      typename T4 = null_type,
+      typename T5 = null_type,
+      typename T6 = null_type,
+      typename T7 = null_type,
+      typename T8 = null_type,
+      typename T9 = null_type,
+      typename T10 = null_type
+    >
+    class tuple;
+
+// forward declaration of cons
+    template<typename Head, typename Tail = null_type>
+    struct cons;
+
     namespace detail {
 
       // Takes a pointer and routes all assignments to whatever it points to
@@ -77,57 +91,125 @@ namespace tuples {
       struct swallow_assign
       {
         template<typename T>
-        swallow_assign& operator=(const 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 = null_type>
+   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;
 
-     typename boost::add_reference<head_type>::type get_head() { return head; }
-     typename boost::add_reference<tail_type>::type get_tail() { return 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() {}
 
-     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(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
+      cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
                     const Tail& t) : head(h), tail(t.head, t.tail)
       {
       }
 
-      explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
+      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(const head_type& h, const T& t) : 
+      explicit cons(head_cref h, const T& t) :
         head(h), tail(t.head, t.tail)
       {
       }
 
-      explicit cons(const head_type& h = head_type(),
-                    const tail_type& t = tail_type()) :
+      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)
@@ -137,13 +219,13 @@ namespace tuples {
         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>
@@ -163,15 +245,15 @@ namespace tuples {
 
       // 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 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
@@ -231,6 +313,58 @@ 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
@@ -254,6 +388,7 @@ namespace tuples {
         typedef typename add_reference<const elt_type>::type RET;
         typedef RET type;
       };
+#endif // vc7
 
     } // namespace detail
 
@@ -264,6 +399,10 @@ namespace tuples {
       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>
     {
@@ -317,18 +456,18 @@ namespace tuples {
 
     // tuple class
     template<
-      typename T1, 
-      typename T2 = null_type, 
-      typename T3 = null_type, 
-      typename T4 = null_type,
-      typename T5 = null_type,
-      typename T6 = null_type,
-      typename T7 = null_type,
-      typename T8 = null_type,
-      typename T9 = null_type,
-      typename T10 = null_type
+      typename T1,
+      typename T2,
+      typename T3,
+      typename T4,
+      typename T5,
+      typename T6,
+      typename T7,
+      typename T8,
+      typename T9,
+      typename T10
     >
-    class tuple : 
+    class tuple :
       public detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
     {
     private:
@@ -344,25 +483,45 @@ 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(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()) :
+      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>
-      explicit tuple(const cons<Head, Tail>& other) : 
+      tuple(const cons<Head, Tail>& other) :
         cons1(other.head, other.tail)
       {
       }
@@ -458,7 +617,7 @@ namespace tuples {
     {
       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
@@ -507,7 +666,7 @@ namespace tuples {
     // Tie variables into a tuple
     template<typename T1, typename T2>
     inline
-    tuple<detail::assign_to_pointee<T1>, 
+    tuple<detail::assign_to_pointee<T1>,
       detail::assign_to_pointee<T2> >
     tie(T1& t1, T2& t2)
     {
@@ -518,8 +677,8 @@ namespace tuples {
     // Tie variables into a tuple
     template<typename T1, typename T2, typename T3>
     inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
+    tuple<detail::assign_to_pointee<T1>,
+      detail::assign_to_pointee<T2>,
       detail::assign_to_pointee<T3> >
     tie(T1& t1, T2& t2, T3& t3)
     {
@@ -531,9 +690,9 @@ namespace tuples {
     // 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>, 
+    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)
     {
@@ -546,10 +705,10 @@ namespace tuples {
     // 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>, 
+    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)
     {
@@ -563,11 +722,11 @@ namespace tuples {
     // 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>, 
+    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)
     {
@@ -575,19 +734,19 @@ namespace tuples {
                         detail::assign_to_pointee<T2>(&t2),
                         detail::assign_to_pointee<T3>(&t3),
                         detail::assign_to_pointee<T4>(&t4),
-                        detail::assign_to_pointee<T6>(&t5),
-                        detail::assign_to_pointee<T5>(&t6));
+                        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>, 
+    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)
     {
@@ -603,13 +762,13 @@ namespace tuples {
     // 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>, 
+    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)
     {
@@ -626,14 +785,14 @@ namespace tuples {
     // 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>, 
+    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)
     {
@@ -650,15 +809,15 @@ namespace tuples {
     // 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>, 
+    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)
     {
@@ -673,10 +832,9 @@ namespace tuples {
                         detail::assign_to_pointee<T9>(&t9),
                         detail::assign_to_pointee<T10>(&t10));
     }
-    // "ignore" allows tuple positions to be ignored when using "tie". 
-    namespace {
-      detail::swallow_assign ignore;
-    }
+    // "ignore" allows tuple positions to be ignored when using "tie".
+
+detail::swallow_assign const ignore = detail::swallow_assign();
 
 } // namespace tuples
 } // namespace boost

include/boost/tuple/reference_wrappers.hpp

@@ -1,57 +0,0 @@
-// -- reference_wrappers - Boost Tuple Library -----------------------------
-
-// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-//
-// For more information, see http://www.boost.org 
-
-// ----------------------------------------------------------------- 
-
-#ifndef BOOST_TUPLE_REFERENCE_WRAPPERS_HPP
-#define BOOST_TUPLE_REFERENCE_WRAPPERS_HPP
-
-namespace boost {
-
-
-// reference wrappers -------------------------------------------------------
-  
-// These wrappers are handle classes that hold references to objects.
-
-// reference_wrapper is used to specify that a tuple element should be 
-// a reference to the wrapped object - rather than a copy of it.
-// The wrapper acts as a disguise for passing non-const reference 
-// parameters via a reference to const parameter.
-
-template<class T>
-class reference_wrapper { 
-  T& x; 
-public:
-  explicit 
-  reference_wrapper(T& t) : x(t) {} 
-  operator T&() const { return x; }
-};
-
-// store as a reference to T
-template<class T> 
-inline const reference_wrapper<T> ref(T& t) { 
-  return reference_wrapper<T>(t); 
-}
-
-// store as a reference to const T
-template<class T> 
-inline const reference_wrapper<const T> cref(const T& t) {
-  return reference_wrapper<const T>(t); 
-}
-   
-} // end of namespace boost
-
-
-#endif	// BOOST_TUPLE_REFERENCE_WRAPPERS_HPP

include/boost/tuple/tuple.hpp

@@ -2,14 +2,9 @@
 
 // Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //
-// Permission to copy, use, sell and distribute this software is granted
-// 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.
+// 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
 
@@ -18,6 +13,13 @@
 #ifndef BOOST_TUPLE_HPP
 #define BOOST_TUPLE_HPP
 
+#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
+// Work around a compiler bug.
+// boost::python::tuple has to be seen by the compiler before the
+// boost::tuple class template.
+namespace boost { namespace python { class tuple; }}
+#endif
+
 #include "boost/config.hpp"
 #include "boost/static_assert.hpp"
 
@@ -27,19 +29,62 @@
 
 #else
 // other compilers
-#include "boost/tuple/reference_wrappers.hpp"
+#include "boost/ref.hpp"
 #include "boost/tuple/detail/tuple_basic.hpp"
 
 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
-namespace boost {				    
+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

@@ -3,14 +3,9 @@
 // Copyright (C) 2001 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
 //
-// Permission to copy, use, sell and distribute this software is granted
-// 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.
+// 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
 // 
@@ -69,7 +64,7 @@ inline bool neq(const T1& lhs, const T2& rhs) {
          neq(lhs.get_tail(), rhs.get_tail());
 }
 template<>
-inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return true; }
+inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return false; }
 
 template<class T1, class T2>
 inline bool lt(const T1& lhs, const T2& rhs) {
@@ -177,4 +172,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

@@ -3,14 +3,9 @@
 // Copyright (C) 2001 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //               2001 Gary Powell (gary.powell@sierra.com)
 //
-// Permission to copy, use, sell and distribute this software is granted
-// 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.
+// 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 
 
 // ----------------------------------------------------------------------------
@@ -25,7 +20,7 @@
 #   if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97) 
 #define BOOST_NO_TEMPLATED_STREAMS
 #endif
-#endif	// __GNUC__
+#endif // __GNUC__
 
 #if defined BOOST_NO_TEMPLATED_STREAMS
 #include <iostream>
@@ -36,8 +31,23 @@
 
 #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 {
 
@@ -45,11 +55,19 @@ namespace detail {
 
 class format_info {
 public:   
+
    enum manipulator_type { open, close, delimiter };
    BOOST_STATIC_CONSTANT(int, number_of_manipulators = delimiter + 1);
 private:
    
-   static const int stream_index[number_of_manipulators];
+   static int get_stream_index (int m)
+   {
+     static const int stream_index[number_of_manipulators]
+        = { std::ios::xalloc(), std::ios::xalloc(), std::ios::xalloc() };
+
+     return stream_index[m];
+   }
+
    format_info(const format_info&);
    format_info();   
 
@@ -58,21 +76,21 @@ public:
 
 #if defined (BOOST_NO_TEMPLATED_STREAMS)
    static char get_manipulator(std::ios& i, manipulator_type m) {
-     char c = static_cast<char>(i.iword(stream_index[m])); 
+     char c = static_cast<char>(i.iword(get_stream_index(m))); 
      
      // parentheses and space are the default manipulators
      if (!c) {
        switch(m) {
-         case open : c = '('; break;					    
-         case close : c = ')'; break;					    
-         case delimiter : c = ' '; break;
+         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(stream_index[m]) = static_cast<long>(c);
+      i.iword(get_stream_index(m)) = static_cast<long>(c);
    }
 #else
    template<class CharType, class CharTrait>
@@ -82,13 +100,13 @@ public:
      // A valid instanitation of basic_stream allows CharType to be any POD,
      // hence, the static_cast may fail (it fails if long is not convertible 
      // to CharType
-     CharType c = static_cast<CharType>(i.iword(stream_index[m]) ); 
+     CharType c = static_cast<CharType>(i.iword(get_stream_index(m)) ); 
      // parentheses and space are the default manipulators
      if (!c) {
        switch(m) {
-         case open :  c = i.widen('('); break;					    
-         case close : c = i.widen(')'); break;					    
-         case delimiter : c = i.widen(' '); break;
+         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;
@@ -102,9 +120,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(stream_index[m]) = static_cast<long>(c);
+      i.iword(get_stream_index(m)) = static_cast<long>(c);
    }
-#endif	// BOOST_NO_TEMPLATED_STREAMS
+#endif // BOOST_NO_TEMPLATED_STREAMS
 };
 
 } // end of namespace detail
@@ -133,8 +151,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)
@@ -204,7 +222,7 @@ template<class T1>
 inline std::ostream& print(std::ostream& o, const cons<T1, null_type>& t) {
   return o << t.head;
 }
-#endif	// BOOST_NO_TEMPLATED_STREAMS
+#endif // BOOST_NO_TEMPLATED_STREAMS
  
 inline std::ostream& print(std::ostream& o, const null_type&) { return o; }
 
@@ -218,7 +236,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;
   
@@ -255,14 +273,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
 
@@ -306,7 +324,7 @@ operator<<(std::basic_ostream<CharType, CharTrait>& o,
 
   return o;
 }
-#endif	// BOOST_NO_TEMPLATED_STREAMS
+#endif // BOOST_NO_TEMPLATED_STREAMS
 
    
 // -------------------------------------------------------------
@@ -322,12 +340,16 @@ extract_and_check_delimiter(
 {
   const char d = format_info::get_manipulator(is, del);
 
-  const bool is_delimiter = (!isspace(d) );      
+#if defined (BOOST_NO_STD_LOCALE)
+  const bool is_delimiter = !isspace(d);
+#else
+  const bool is_delimiter = (!std::isspace(d, is.getloc()) );            
+#endif
 
   char c;
   if (is_delimiter) { 
     is >> c; 
-    if (c!=d) {
+    if (is.good() && c!=d) {
       is.setstate(std::ios::failbit);
     } 
   }
@@ -349,7 +371,7 @@ read (std::istream &is, cons<T1, null_type>& t1) {
 }
 #else
 inline std::istream& read(std::istream& i, const null_type&) { return i; }
-#endif	// !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    
 template<class T1, class T2>
 inline std::istream& 
@@ -361,7 +383,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);
@@ -409,12 +431,19 @@ extract_and_check_delimiter(
 {
   const CharType d = format_info::get_manipulator(is, del);
 
-  const bool is_delimiter = (!isspace(d) );      
+#if defined (BOOST_NO_STD_LOCALE)
+  const bool is_delimiter = !isspace(d);
+#elif defined ( __BORLANDC__ )
+  const bool is_delimiter = !std::use_facet< std::ctype< CharType > >
+    (is.getloc() ).is( std::ctype_base::space, d);
+#else
+  const bool is_delimiter = (!std::isspace(d, is.getloc()) );            
+#endif
 
   CharType c;
   if (is_delimiter) { 
     is >> c;
-    if (c!=d) { 
+    if (is.good() && c!=d) { 
       is.setstate(std::ios::failbit);
     }
   }
@@ -436,7 +465,7 @@ template<class CharType, class CharTrait>
 inline std::basic_istream<CharType, CharTrait>& 
 read(std::basic_istream<CharType, CharTrait>& i, const null_type&) { return i; }
 
-#endif	// !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 template<class CharType, class CharTrait, class T1, class T2>
 inline std::basic_istream<CharType, CharTrait>& 
@@ -448,7 +477,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);
@@ -486,11 +515,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

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

@@ -1,14 +0,0 @@
-To compile the 
-
-libs/tuple/test/*.cpp 
-
-files, you need to set include paths
-for boost.
-For example, in libs/tuple/test directory you would type (using g++):
-
-g++ -I../../.. tuple_test_bench.cpp
-
-If you want to use tuple_io, you need to compile and link src/tuple.cpp:
-
-g++ -I../../.. ../src/tuple.cpp io_test.cpp
-

test/another_tuple_test_bench.cpp

@@ -1,158 +0,0 @@
-//  another_test_bench.cpp  --------------------------------
-
-// This file has various tests to see that things that shouldn't
-// compile, don't compile.
-
-// Defining any of E1 to E5 or E7 to E11 opens some illegal code that 
-// should cause the compliation to fail.
-
-#define BOOST_INCLUDE_MAIN  // for testing, include rather than link
-#include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
-
-#include "boost/tuple/tuple.hpp"
-
-#include <string>
-#include <utility>
-
-using namespace std;
-using namespace boost;
-using namespace boost::tuples;
-
-
-template<class T> void dummy(const T&) {}
-
-class A {}; class B {}; class C {};
-
-// A non-copyable class
-class no_copy {
-  no_copy(const no_copy&) {}
-public:
-  no_copy() {};
-};
-
-no_copy y;
-
-#ifdef E1
-tuple<no_copy> v1;  // should faild
-#endif
-
-
-#ifdef E2
-char cs[10];
-tuple<char[10]> v3;  // should fail, arrays must be stored as references
-#endif
-
-// a class without a public default constructor
-class no_def_constructor {
-  no_def_constructor() {}
-public:
-  no_def_constructor(std::string) {} // can be constructed with a string
-};
-
-void foo1() {
-
-#ifdef E3
-  dummy(tuple<no_def_constructor, no_def_constructor, no_def_constructor>()); 
-  // should fail
-
-#endif
-}
-
-void foo2() {
-// testing default values
-#ifdef E4
-  dummy(tuple<double&>()); // should fail, not defaults for references
-  dummy(tuple<const double&>()); // likewise
-#endif
-
-  double dd = 5;
-
-#ifdef E5
-  dummy(tuple<double&>(dd+3.14)); // should fail, temporary to non-const reference
-#endif
-}
-
-
-
-// make_tuple ------------------------------------------
-
-
-   void foo3() {
-#ifdef E7
-    std::make_pair("Doesn't","Work"); // fails
-#endif
-    //    make_tuple("Does", "Work"); // this should work
-}
-
-
-
-// - testing element access
-
-void foo4() 
-{
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  double d = 2.7; 
-  A a;
-  tuple<int, double&, const A&> t(1, d, a);
-  const tuple<int, double&, const A> ct = t;
-
-#ifdef E8
-  get<0>(ct) = 5; // can't assign to const
-#endif
-
-#ifdef E9
-  get<4>(t) = A(); // can't assign to const
-#endif
-#ifdef E10
-  dummy(get<5>(ct)); // illegal index
-#endif
-
-#endif
-}
-
-// testing copy and assignment with implicit conversions between elements
-// testing tie
-
-  class AA {};
-  class BB : public AA {};
-  struct CC { CC() {} CC(const BB& b) {} };
-  struct DD { operator CC() const { return CC(); }; };
-
-  void foo5() {
-    tuple<char, BB*, BB, DD> t;
-
-    tuple<char, char> aaa;
-    tuple<int, int> bbb(aaa);
-    //    tuple<int, AA*, CC, CC> a = t;
-    //    a = t;
-  }
-
-
-// testing tie
-// testing assignment from std::pair
-void foo7() {
-
-   tuple<int, int, float> a;
-#ifdef E11
-   a = std::make_pair(1, 2); // should fail, tuple is of length 3, not 2
-#endif
-
-    dummy(a);
-}
-
-
-
-// --------------------------------
-// ----------------------------
-int test_main(int, char *[]) {
-
-  foo1();
-  foo2();
-  foo3();
-  foo4();
-  foo5();
-
-  foo7();
-
-  return 0;
-}

test/io_test.cpp

@@ -1,108 +0,0 @@
-// -- io_test.cpp -----------------------------------------------
-//
-// Testing the I/O facilities of tuples
-
-#define BOOST_INCLUDE_MAIN  // for testing, include rather than link
-#include "boost/test/test_tools.hpp"    // see "Header Implementation Option"
-
-#include "boost/tuple/tuple_io.hpp"
-#include "boost/tuple/tuple_comparison.hpp"
-
-#include <fstream>
-#include <iterator>
-#include <algorithm>
-#include <string>
-
-#if defined BOOST_NO_STRINGSTREAM
-#include <strstream>
-#else
-#include <sstream>
-#endif
-
-#include "boost/config.hpp"
-
-using namespace std;
-using namespace boost;
-
-#if defined BOOST_NO_STRINGSTREAM
-typedef ostrstream useThisOStringStream;
-typedef istrstream useThisIStringStream;
-#else
-typedef ostringstream useThisOStringStream;
-typedef istringstream useThisIStringStream;
-#endif
-
-int test_main(int argc, char * argv[] ) {
-
-   using boost::tuples::set_close;
-   using boost::tuples::set_open;
-   using boost::tuples::set_delimiter;
-   
-  useThisOStringStream os1;
-
-  // Set format [a, b, c] for os1
-  os1 << set_open('[');
-  os1 << set_close(']');
-  os1 << set_delimiter(',');
-  os1 << make_tuple(1, 2, 3);
-  BOOST_TEST (os1.str() == std::string("[1,2,3]") );
-
-  {
-  useThisOStringStream os2;
-  // Set format (a:b:c) for os2; 
-  os2 << set_open('(');
-  os2 << set_close(')');
-  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)") );
-#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]") );
-
-  ofstream tmp("temp.tmp");
-
-#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  tmp << make_tuple("One", "Two", 3);
-#endif   
-  tmp << set_delimiter(':');
-  tmp << make_tuple(1000, 2000, 3000) << endl;
-
-  tmp.close();
-  
-  // When teading tuples from a stream, manipulators must be set correctly:
-  ifstream tmp3("temp.tmp");
-  tuple<string, string, int> j;		    
-
-#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  tmp3 >> j; 
-  BOOST_TEST (tmp3.good() ); 
-#endif
-   
-  tmp3 >> set_delimiter(':');
-  tuple<int, int, int> i;
-  tmp3 >> i; 
-  BOOST_TEST (tmp3.good() ); 
-   
-  tmp3.close(); 
-
-
-  // reading tuple<int, int, int> in format (a b c); 
-  useThisIStringStream is("(100 200 300)"); 
-   
-  tuple<int, int, int> ti; 
-  BOOST_TEST(is >> ti);
-  BOOST_TEST(ti == make_tuple(100, 200, 300));
-   
-
-  // Note that strings are problematic:
-  // writing a tuple on a stream and reading it back doesn't work in
-  // general. If this is wanted, some kind of a parseable string class
-  // should be used.
-  
-  return 0;
-}
-

test/tuple_test_bench.cpp

@@ -1,440 +0,0 @@
-//  tuple_test_bench.cpp  --------------------------------
-
-#define BOOST_INCLUDE_MAIN  // for testing, include rather than link
-#include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
-
-#include "boost/tuple/tuple.hpp"
-
-#include "boost/tuple/tuple_comparison.hpp"
-
-#include <string>
-#include <utility>
-
-using namespace std;
-using namespace boost;
-
-// ----------------------------------------------------------------------------
-// helpers 
-// ----------------------------------------------------------------------------
-
-class A {}; 
-class B {}; 
-class C {};
-
-// classes with different kinds of conversions
-class AA {};
-class BB : public AA {}; 
-struct CC { CC() {} CC(const BB& b) {} };
-struct DD { operator CC() const { return CC(); }; };
-
-// something to prevent warnings for unused variables
-template<class T> void dummy(const T&) {}
-
-// no public default constructor
-class foo {
-public:
-  explicit foo(int v) : val(v) {}
-
-  bool operator==(const foo& other) const  {
-    return val == other.val;
-  }
-
-private:
-  foo() {}
-  int val;
-};
-
-// another class without a public default constructor
-class no_def_constructor {
-  no_def_constructor() {}
-public:
-  no_def_constructor(std::string) {}
-};
-
-// A non-copyable class 
-class no_copy {
-  no_copy(const no_copy&) {}
-public:
-  no_copy() {};
-};
-
-
-// ----------------------------------------------------------------------------
-// Testing different element types --------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-typedef tuple<int> t1;
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-typedef tuple<double&, const double&, const double, double*, const double*> t2;
-typedef tuple<A, int(*)(char, int), C> t3;
-typedef tuple<std::string, std::pair<A, B> > t4;
-typedef tuple<A*, tuple<const A*, const B&, C>, bool, void*> t5;
-typedef tuple<volatile int, const volatile char&, int(&)(float) > t6;
-
-# if !defined(__BORLANDC__) || __BORLAND__ > 0x0551
-typedef tuple<B(A::*)(C&), A&> t7;
-#endif
-
-#endif
-
-// -----------------------------------------------------------------------
-// -tuple construction tests ---------------------------------------------
-// -----------------------------------------------------------------------
-
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-no_copy y;
-tuple<no_copy&> x = tuple<no_copy&>(y); // ok
-#endif
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-char cs[10];
-tuple<char(&)[10]> v2(cs);  // ok
-#endif
-
-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; 
-  BOOST_TEST(tuples::get<0>(t1) == int());
-  
-  tuple<float> t2(5.5f);
-  BOOST_TEST(tuples::get<0>(t2) > 5.4f && tuples::get<0>(t2) < 5.6f);
-
-  tuple<foo> t3(foo(12));
-  BOOST_TEST(tuples::get<0>(t3) == foo(12));
-
-  tuple<double> t4(t2);
-  BOOST_TEST(tuples::get<0>(t4) > 5.4 && tuples::get<0>(t4) < 5.6);
-
-  tuple<int, float> t5;
-  BOOST_TEST(tuples::get<0>(t5) == int());
-  BOOST_TEST(tuples::get<1>(t5) == float());
-
-  tuple<int, float> t6(12, 5.5f);
-  BOOST_TEST(tuples::get<0>(t6) == 12);
-  BOOST_TEST(tuples::get<1>(t6) > 5.4f && tuples::get<1>(t6) < 5.6f);
-
-  tuple<int, float> t7(t6);
-  BOOST_TEST(tuples::get<0>(t7) == 12);
-  BOOST_TEST(tuples::get<1>(t7) > 5.4f && tuples::get<1>(t7) < 5.6f);
-
-  tuple<long, double> t8(t6);
-  BOOST_TEST(tuples::get<0>(t8) == 12);
-  BOOST_TEST(tuples::get<1>(t8) > 5.4f && tuples::get<1>(t8) < 5.6f);
-
-  dummy( 
-    tuple<no_def_constructor, no_def_constructor, no_def_constructor>(
-       std::string("Jaba"),   // ok, since the default 
-       std::string("Daba"),   // constructor is not used
-       std::string("Doo")
-    )
-  );
-
-// testing default values
-  dummy(tuple<int, double>());
-  dummy(tuple<int, double>(1));
-  dummy(tuple<int, double>(1,3.14)); 
-
-
-  //  dummy(tuple<double&>()); // should fail, not defaults for references
-  //  dummy(tuple<const double&>()); // likewise
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  double dd = 5;
-  dummy(tuple<double&>(dd)); // ok
-
-  dummy(tuple<const double&>(dd+3.14)); // ok, but dangerous
-#endif
-
-  //  dummy(tuple<double&>(dd+3.14)); // should fail, 
-  //                                  // temporary to non-const reference
-
-}
-
-
-// ----------------------------------------------------------------------------
-// - testing element access ---------------------------------------------------
-// ----------------------------------------------------------------------------
-
-void element_access_test() 
-{
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  double d = 2.7; 
-  A a;
-  tuple<int, double&, const A&> t(1, d, a);
-  const tuple<int, double&, const A> ct = t;
-
-  int i = tuples::get<0>(t);
-  int j = tuples::get<0>(ct);
-  BOOST_TEST(i == 1 && j == 1);
-   
-  tuples::get<0>(t) = 5;
-  BOOST_TEST(t.head == 5);
-   
-  //  tuples::get<0>(ct) = 5; // can't assign to const
-
-  double e = tuples::get<1>(t);
-  BOOST_TEST(e > 2.69 && e < 2.71);
-	     
-  tuples::get<1>(t) = 3.14+i;
-  BOOST_TEST(tuples::get<1>(t) > 4.13 && tuples::get<1>(t) < 4.15);
-
-  //  tuples::get<4>(t) = A(); // can't assign to const
-  //  dummy(tuples::get<5>(ct)); // illegal index
-
-  ++tuples::get<0>(t);
-  BOOST_TEST(tuples::get<0>(t) == 6);
-
-  dummy(i); dummy(j); dummy(e); // avoid warns for unused variables
-#endif
-}
-
-
-// ----------------------------------------------------------------------------
-// - copying tuples -----------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-
-void
-copy_test()
-{
-  tuple<int, char> t1(4, 'a');
-  tuple<int, char> t2(5, 'b');
-  t2 = t1;
-  BOOST_TEST(tuples::get<0>(t1) == tuples::get<0>(t2));
-  BOOST_TEST(tuples::get<1>(t1) == tuples::get<1>(t2));
-
-  tuple<long, std::string> t3(2, "a");
-  t3 = t1;
-  BOOST_TEST((double)tuples::get<0>(t1) == tuples::get<0>(t3));
-  BOOST_TEST(tuples::get<1>(t1) == tuples::get<1>(t3)[0]);
-
-// testing copy and assignment with implicit conversions between elements
-// testing tie
-
-  tuple<char, BB*, BB, DD> t;
-  tuple<int, AA*, CC, CC> a(t);
-  a = t;
-
-  int i; char c; double d;
-  tie(i, c, d) = make_tuple(1, 'a', 5.5);
-  
-  BOOST_TEST(i==1);
-  BOOST_TEST(c=='a');
-  BOOST_TEST(d>5.4 && d<5.6);
-}
-
-void
-mutate_test()
-{
-  tuple<int, float, bool, foo> t1(5, 12.2f, true, foo(4));
-  tuples::get<0>(t1) = 6;
-  tuples::get<1>(t1) = 2.2f;
-  tuples::get<2>(t1) = false;
-  tuples::get<3>(t1) = foo(5);
-
-  BOOST_TEST(tuples::get<0>(t1) == 6);
-  BOOST_TEST(tuples::get<1>(t1) > 2.1f && tuples::get<1>(t1) < 2.3f);
-  BOOST_TEST(tuples::get<2>(t1) == false);
-  BOOST_TEST(tuples::get<3>(t1) == foo(5));
-}
-
-// ----------------------------------------------------------------------------
-// make_tuple tests -----------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-void
-make_tuple_test()
-{
-  tuple<int, char> t1 = make_tuple(5, 'a');
-  BOOST_TEST(tuples::get<0>(t1) == 5);
-  BOOST_TEST(tuples::get<1>(t1) == 'a');
-
-  tuple<int, std::string> t2;
-  t2 = make_tuple((short int)2, std::string("Hi"));
-  BOOST_TEST(tuples::get<0>(t2) == 2);
-  BOOST_TEST(tuples::get<1>(t2) == "Hi");
-
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-    A a; B b;
-    const A ca = a;
-    make_tuple(cref(a), b);
-    make_tuple(ref(a), b);
-    make_tuple(ref(a), cref(b));
-
-    make_tuple(ref(ca));
-#endif
-     
-// the result of make_tuple is assignable:
-   BOOST_TEST(make_tuple(2, 4, 6) == 
-	     (make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-    make_tuple("Donald", "Daisy"); // should work;
-#endif
-    //    std::make_pair("Doesn't","Work"); // fails
-
-// You can store a reference to a function in a tuple
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-    tuple<void(&)()> adf(make_tuple_test);
-
-    dummy(adf); // avoid warning for unused variable
-#endif
- 
-// But make_tuple doesn't work 
-// with function references, since it creates a const qualified function type
-
-//   make_tuple(make_tuple_test);
-  
-// With function pointers, make_tuple works just fine
-
-#if !defined(__BORLANDC__) || __BORLAND__ > 0x0551
-   make_tuple(&make_tuple_test);
-#endif
-      
-// NOTE:
-//
-// wrapping it the function reference with ref helps on gcc 2.95.2.
-// on edg 2.43. it results in a catastrophic error?
-
-// make_tuple(ref(foo3));
-
-// It seems that edg can't use implicitly the ref's conversion operator, e.g.:
-// typedef void (&func_t) (void);
-// func_t fref = static_cast<func_t>(ref(make_tuple_test)); // works fine 
-// func_t fref = ref(make_tuple_test);                        // error
-
-// This is probably not a very common situation, so currently
-// I don't know how which compiler is right (JJ)
-}
-
-void
-tie_test()
-{
-  int a;
-  char b;
-  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));
-
-  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));
-
-// testing assignment from std::pair
-   int i, j; 
-   tie (i, j) = std::make_pair(1, 2);
-   BOOST_TEST(i == 1 && j == 2);
-
-   tuple<int, int, float> ta;
-#ifdef E11
-   ta = std::make_pair(1, 2); // should fail, tuple is of length 3, not 2
-#endif
-
-   dummy(ta);
-}
-
-
-// ----------------------------------------------------------------------------
-// - testing tuple equality   -------------------------------------------------
-// ----------------------------------------------------------------------------
-
-void
-equality_test()
-{
-  tuple<int, char> t1(5, 'a');
-  tuple<int, char> t2(5, 'a');
-  BOOST_TEST(t1 == t2);
-
-  tuple<int, char> t3(5, 'b');
-  tuple<int, char> t4(2, 'a');
-  BOOST_TEST(t1 != t3);
-  BOOST_TEST(t1 != t4);
-}
-
-
-// ----------------------------------------------------------------------------
-// - testing tuple comparisons  -----------------------------------------------
-// ----------------------------------------------------------------------------
-
-void
-ordering_test()
-{
-  tuple<int, float> t1(4, 3.3f);
-  tuple<short, float> t2(5, 3.3f);
-  tuple<long, double> t3(5, 4.4);
-  BOOST_TEST(t1 < t2);
-  BOOST_TEST(t1 <= t2);
-  BOOST_TEST(t2 > t1);
-  BOOST_TEST(t2 >= t1);
-  BOOST_TEST(t2 < t3);
-  BOOST_TEST(t2 <= t3);
-  BOOST_TEST(t3 > t2);
-  BOOST_TEST(t3 >= t2);
-
-}
-
-
-// ----------------------------------------------------------------------------
-// - testing cons lists -------------------------------------------------------
-// ----------------------------------------------------------------------------
-void cons_test()
-{
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  using tuples::cons;
-  using tuples::null_type;
-
-  cons<volatile float, null_type> a(1, null_type());
-  cons<const int, cons<volatile float, null_type> > b(2,a);
-  int i = 3;
-  cons<int&, cons<const int, cons<volatile float, null_type> > > c(i, b);
-  BOOST_TEST(make_tuple(3,2,1)==c);
-
-  cons<char, cons<int, cons<float, null_type> > > x;
-
-#endif
-}
-
-// ----------------------------------------------------------------------------
-// - testing const tuples -----------------------------------------------------
-// ----------------------------------------------------------------------------
-void const_tuple_test()
-{
-  const tuple<int, float> t1(5, 3.3f);
-  BOOST_TEST(tuples::get<0>(t1) == 5);
-  BOOST_TEST(tuples::get<1>(t1) == 3.3f);
-}
-
-
-// ----------------------------------------------------------------------------
-// - main ---------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-int test_main(int, char *[]) {
-
-  construction_test();
-  element_access_test();
-  copy_test();
-  mutate_test();
-  make_tuple_test();
-  tie_test();
-  equality_test();
-  ordering_test();
-  cons_test();
-  const_tuple_test();
-  return 0;
-}