moved some tests that require user interaction from tuple_test_bench.cpp

to another_tuple_test_bench.cpp [SVN r11059]
tuples in separate namespaces now compile under MSVC++ as well
2001-09-07 11:04:50 +00:00 · 2001-09-07 11:02:01 +00:00 · 2001-09-06 22:25:15 +00:00 · 2001-09-06 13:51:22 +00:00 · 2001-09-06 13:50:27 +00:00 · 2001-09-06 13:49:31 +00:00
11 changed files with 1209 additions and 815 deletions
--- a/include/boost/tuple/detail/tuple_basic.hpp
+++ b/include/boost/tuple/detail/tuple_basic.hpp
--- a/include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp
+++ b/include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp
@ -1,27 +1,32 @@
 // - tuple_basic_no_partial_spec.hpp -----------------------------------------

 // Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2001 Douglas Gregor (gregod@rpi.edu)
+// Copyright (C) 2001 Doug Gregor (gregod@rpi.edu)
 // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
 //
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// 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 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
@ -39,34 +44,15 @@ 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
@ -91,125 +77,57 @@ namespace tuples {
      struct swallow_assign
      {
        template<typename T>
-        swallow_assign const& operator=(const T&) const
+        swallow_assign& operator=(const T&)
        {
          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>
+   template<typename Head, typename Tail = null_type>
   struct cons
   {
     typedef cons self_type;
     typedef Head head_type;
     typedef Tail tail_type;

-    private:
-       typedef typename boost::add_reference<head_type>::type head_ref;
-       typedef typename boost::add_reference<tail_type>::type tail_ref;
-       typedef typename detail::add_const_reference<head_type>::type head_cref;
-       typedef typename detail::add_const_reference<tail_type>::type tail_cref;
-    public:
     head_type head;
     tail_type tail;

-     head_ref get_head() { return head; }
-     tail_ref get_tail() { return tail; }
-
-     head_cref get_head() const { return head; }
-     tail_cref get_tail() const { return tail; }
-
-     cons() : head(), tail() {}
+     typename boost::add_reference<head_type>::type get_head() { return head; }
+     typename boost::add_reference<tail_type>::type get_tail() { return tail; }  

+     typename boost::add_reference<const head_type>::type get_head() const { return head; }
+     typename boost::add_reference<const tail_type>::type get_tail() const { return tail; }
+  
 #if defined BOOST_MSVC
      template<typename Tail>
-      cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
+      explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
                    const Tail& t) : head(h), tail(t.head, t.tail)
      {
      }

-      cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
+      explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
                    const null_type& t) : head(h), tail(t)
      {
      }

 #else
      template<typename T>
-      explicit cons(head_cref h, const T& t) :
+      explicit cons(const head_type& h, const T& t) : 
        head(h), tail(t.head, t.tail)
      {
      }

-      explicit cons(head_cref h = head_type(),
-                    tail_cref t = tail_type()) :
+      explicit cons(const head_type& h = head_type(),
+                    const tail_type& t = tail_type()) :
        head(h), tail(t)
      {
      }
 #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)
@ -219,13 +137,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>
@ -245,15 +163,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
@ -313,58 +231,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
@ -388,7 +254,6 @@ namespace tuples {
        typedef typename add_reference<const elt_type>::type RET;
        typedef RET type;
      };
-#endif // vc7

    } // namespace detail

@ -399,10 +264,6 @@ 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>
    {
@ -456,18 +317,18 @@ namespace tuples {

    // tuple class
    template<
-      typename T1,
-      typename T2,
-      typename T3,
-      typename T4,
-      typename T5,
-      typename T6,
-      typename T7,
-      typename T8,
-      typename T9,
-      typename T10
+      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
    >
-    class tuple :
+    class tuple : 
      public detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
    {
    private:
@ -483,45 +344,25 @@ 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;

-      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()
-      ) :
+      explicit tuple(const T1& t1 = T1(), 
+                     const T2& t2 = T2(),
+                     const T3& t3 = T3(),
+                     const T4& t4 = T4(),
+                     const T5& t5 = T5(),
+                     const T6& t6 = T6(),
+                     const T7& t7 = T7(),
+                     const T8& t8 = T8(),
+                     const T9& t9 = T9(),
+                     const T10& t10 = T10()) :
        cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10))))))))))
      {
      }

-      explicit tuple(t1_cref t1)
-        : cons1(t1, cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
-      {}
-
      template<typename Head, typename Tail>
-      tuple(const cons<Head, Tail>& other) :
+      explicit tuple(const cons<Head, Tail>& other) : 
        cons1(other.head, other.tail)
      {
      }
@ -617,7 +458,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
@ -666,7 +507,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)
    {
@ -677,8 +518,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)
    {
@ -690,9 +531,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)
    {
@ -705,10 +546,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)
    {
@ -722,11 +563,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)
    {
@ -734,19 +575,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<T5>(&t5),
-                        detail::assign_to_pointee<T6>(&t6));
+                        detail::assign_to_pointee<T6>(&t5),
+                        detail::assign_to_pointee<T5>(&t6));
    }

    // Tie variables into a tuple
    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)
    {
@ -762,13 +603,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)
    {
@ -785,14 +626,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)
    {
@ -809,15 +650,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)
    {
@ -832,9 +673,10 @@ namespace tuples {
                        detail::assign_to_pointee<T9>(&t9),
                        detail::assign_to_pointee<T10>(&t10));
    }
-    // "ignore" allows tuple positions to be ignored when using "tie".
-
-detail::swallow_assign const ignore = detail::swallow_assign();
+    // "ignore" allows tuple positions to be ignored when using "tie". 
+    namespace {
+      detail::swallow_assign ignore;
+    }

 } // namespace tuples
 } // namespace boost
--- a/include/boost/tuple/reference_wrappers.hpp
+++ b/include/boost/tuple/reference_wrappers.hpp
@ -0,0 +1,57 @@
+// -- 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
--- a/include/boost/tuple/tuple.hpp
+++ b/include/boost/tuple/tuple.hpp
@ -2,9 +2,14 @@

 // Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// 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

@ -13,13 +18,6 @@
 #ifndef BOOST_TUPLE_HPP
 #define BOOST_TUPLE_HPP

-#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
-// Work around a compiler bug.
-// boost::python::tuple has to be seen by the compiler before the
-// boost::tuple class template.
-namespace boost { namespace python { class tuple; }}
-#endif
-
 #include "boost/config.hpp"
 #include "boost/static_assert.hpp"

@ -29,62 +27,19 @@ namespace boost { namespace python { class tuple; }}

 #else
 // other compilers
-#include "boost/ref.hpp"
+#include "boost/tuple/reference_wrappers.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
--- a/include/boost/tuple/tuple_comparison.hpp
+++ b/include/boost/tuple/tuple_comparison.hpp
@ -3,9 +3,14 @@
 // Copyright (C) 2001 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
 //
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// 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
 // 
@ -64,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) {
@ -172,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
--- a/include/boost/tuple/tuple_io.hpp
+++ b/include/boost/tuple/tuple_io.hpp
@ -3,9 +3,14 @@
 // Copyright (C) 2001 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //               2001 Gary Powell (gary.powell@sierra.com)
 //
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// 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 

 // ----------------------------------------------------------------------------
@ -20,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>
@ -31,23 +36,8 @@

 #include "boost/tuple/tuple.hpp"

-// This is ugly: one should be using twoargument isspace since whitspace can
-// be locale dependent, in theory at least.
-// not all libraries implement have the two-arg version, so we need to 
-// use the one-arg one, which one should get with <cctype> but there seem
-// to be exceptions to this.
-
-#if !defined (BOOST_NO_STD_LOCALE)
-
-#include <locale> // for two-arg isspace
-
-#else 
-
-#include <cctype> // for one-arg (old) isspace 
-#include <ctype.h> // Metrowerks does not find one-arg isspace from cctype
-
-#endif

+				    
 namespace boost {
 namespace tuples {

@ -55,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]
-        = { std::ios::xalloc(), std::ios::xalloc(), std::ios::xalloc() };
-
-     return stream_index[m];
-   }
-
+   static const int stream_index[number_of_manipulators];
   format_info(const format_info&);
   format_info();   

@ -76,21 +58,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(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 detail::format_info::open : c = '('; break;
-         case detail::format_info::close : c = ')'; break;
-         case detail::format_info::delimiter : c = ' '; break;
+         case open : c = '('; break;					    
+         case close : c = ')'; break;					    
+         case delimiter : c = ' '; break;
       }
     }
     return c;
   }

   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>
@ -100,13 +82,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(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 detail::format_info::open :  c = i.widen('('); break;
-         case detail::format_info::close : c = i.widen(')'); break;
-         case detail::format_info::delimiter : c = i.widen(' '); break;
+         case open :  c = i.widen('('); break;					    
+         case close : c = i.widen(')'); break;					    
+         case delimiter : c = i.widen(' '); break;
       }
     }
     return c;
@ -120,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
@ -151,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_TEMPLATED_STREAMS
+#endif	// BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif	// BOOST_NO_TEMPLATED_STREAMS
 };

 #if defined (BOOST_NO_TEMPLATED_STREAMS)
@ -222,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; }

@ -236,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;
  
@ -273,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

@ -324,7 +306,7 @@ operator<<(std::basic_ostream<CharType, CharTrait>& o,

  return o;
 }
-#endif // BOOST_NO_TEMPLATED_STREAMS
+#endif	// BOOST_NO_TEMPLATED_STREAMS

   
 // -------------------------------------------------------------
@ -340,16 +322,12 @@ extract_and_check_delimiter(
 {
  const char d = format_info::get_manipulator(is, del);

-#if defined (BOOST_NO_STD_LOCALE)
-  const bool is_delimiter = !isspace(d);
-#else
-  const bool is_delimiter = (!std::isspace(d, is.getloc()) );            
-#endif
+  const bool is_delimiter = (!isspace(d) );      

  char c;
  if (is_delimiter) { 
    is >> c; 
-    if (is.good() && c!=d) {
+    if (c!=d) {
      is.setstate(std::ios::failbit);
    } 
  }
@ -371,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& 
@ -383,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);
@ -431,19 +409,12 @@ extract_and_check_delimiter(
 {
  const CharType d = format_info::get_manipulator(is, del);

-#if defined (BOOST_NO_STD_LOCALE)
-  const bool is_delimiter = !isspace(d);
-#elif defined ( __BORLANDC__ )
-  const bool is_delimiter = !std::use_facet< std::ctype< CharType > >
-    (is.getloc() ).is( std::ctype_base::space, d);
-#else
-  const bool is_delimiter = (!std::isspace(d, is.getloc()) );            
-#endif
+  const bool is_delimiter = (!isspace(d) );      

  CharType c;
  if (is_delimiter) { 
    is >> c;
-    if (is.good() && c!=d) { 
+    if (c!=d) { 
      is.setstate(std::ios::failbit);
    }
  }
@ -465,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>& 
@ -477,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);
@ -515,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


--- a/src/tuple.cpp
+++ b/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
--- a/test/README
+++ b/test/README
@ -0,0 +1,14 @@
+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
+
--- a/test/another_tuple_test_bench.cpp
+++ b/test/another_tuple_test_bench.cpp
@ -0,0 +1,158 @@
+//  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;
+}
--- a/test/io_test.cpp
+++ b/test/io_test.cpp
@ -0,0 +1,108 @@
+// -- 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;
+}
+
--- a/test/tuple_test_bench.cpp
+++ b/test/tuple_test_bench.cpp
@ -0,0 +1,440 @@
+//  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;
+}
Author	SHA1	Message	Date
Jaakko Järvi	2d62dc5f16	moved some tests that require user interaction from tuple_test_bench.cpp to another_tuple_test_bench.cpp [SVN r11059]	2001-09-07 11:04:50 +00:00
Jaakko Järvi	2a2632a159	tuples in separate namespaces now compile under MSVC++ as well changed tuple_length, tuple_element, tuple_access_traits to tuples::length, tuples::element and tuples::access_traits [SVN r11058]	2001-09-07 11:02:01 +00:00
Douglas Gregor	b8cca277e5	Now works on non-MSVC compilers [SVN r11057]	2001-09-06 22:25:15 +00:00
Jaakko Järvi	c10fd424bc	Definitions now in tuples subnamespace [SVN r11052]	2001-09-06 13:51:22 +00:00
Jaakko Järvi	984cbdc728	tuples subnamespace added [SVN r11051]	2001-09-06 13:50:27 +00:00
Jaakko Järvi	09a730c9bc	most definitions are now in tuples subnamespace, more tests moved to tuple_test_bench.cpp [SVN r11050]	2001-09-06 13:49:31 +00:00
nobody	43ea26d05e	This commit was manufactured by cvs2svn to create branch 'tuples_subnamespace'. [SVN r11026]	2001-09-05 03:22:32 +00:00