Merge pull request #3 from boostorg/develop

Merge some changes to master.

include/boost/tuple/detail/tuple_basic.hpp

@@ -37,9 +37,15 @@
 
 #include "boost/type_traits/cv_traits.hpp"
 #include "boost/type_traits/function_traits.hpp"
+#include "boost/utility/swap.hpp"
 
 #include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND
 
+#if BOOST_GCC >= 40700
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
+#endif
+
 namespace boost {
 namespace tuples {
 
@@ -86,45 +92,28 @@ namespace detail {
 template<class T>
 class generate_error;
 
-// - cons getters --------------------------------------------------------
+template<int N>
-// called: get_class<N>::get<RETURN_TYPE>(aTuple)
+struct drop_front {
-
+    template<class Tuple>
-template< int N >
+    struct apply {
-struct get_class {
+        typedef BOOST_DEDUCED_TYPENAME drop_front<N-1>::BOOST_NESTED_TEMPLATE
-  template<class RET, class HT, class TT >
+            apply<Tuple> next;
-  inline static RET get(const cons<HT, TT>& t)
+        typedef BOOST_DEDUCED_TYPENAME next::type::tail_type type;
-  {
+        static const type& call(const Tuple& tup) {
-#if BOOST_WORKAROUND(__IBMCPP__,==600)
+            return next::call(tup).tail;
-    // vacpp 6.0 is not very consistent regarding the member template keyword
+        }
-    // Here it generates an error when the template keyword is used.
+    };
-    return get_class<N-1>::get<RET>(t.tail);
-#else
-    return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
-#endif
-  }
-  template<class RET, class HT, class TT >
-  inline static RET get(cons<HT, TT>& t)
-  {
-#if BOOST_WORKAROUND(__IBMCPP__,==600)
-    return get_class<N-1>::get<RET>(t.tail);
-#else
-    return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
-#endif
-  }
 };
 
 template<>
-struct get_class<0> {
+struct drop_front<0> {
-  template<class RET, class HT, class TT>
+    template<class Tuple>
-  inline static RET get(const cons<HT, TT>& t)
+    struct apply {
-  {
+        typedef Tuple type;
-    return t.head;
+        static const type& call(const Tuple& tup) {
-  }
+            return tup;
-  template<class RET, class HT, class TT>
+        }
-  inline static RET get(cons<HT, TT>& t)
+    };
-  {
-    return t.head;
-  }
 };
 
 } // end of namespace detail
@@ -140,41 +129,23 @@ struct get_class<0> {
 template<int N, class T>
 struct element
 {
-private:
+  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
-  typedef typename T::tail_type Next;
+      apply<T>::type::head_type type;
-public:
-  typedef typename element<N-1, Next>::type type;
-};
-template<class T>
-struct element<0,T>
-{
-  typedef typename T::head_type type;
 };
 
 template<int N, class T>
 struct element<N, const T>
 {
 private:
-  typedef typename T::tail_type Next;
+  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
-  typedef typename element<N-1, Next>::type unqualified_type;
+      apply<T>::type::head_type unqualified_type;
 public:
 #if BOOST_WORKAROUND(__BORLANDC__,<0x600)
   typedef const unqualified_type type;
 #else
-  typedef typename boost::add_const<unqualified_type>::type type;
+  typedef BOOST_DEDUCED_TYPENAME boost::add_const<unqualified_type>::type type;
-#endif
-
-};
-template<class T>
-struct element<0,const T>
-{
-#if BOOST_WORKAROUND(__BORLANDC__,<0x600)
-  typedef const typename T::head_type type;
-#else
-  typedef typename boost::add_const<typename T::head_type>::type type;
 #endif
 };
-
 #else // def BOOST_NO_CV_SPECIALIZATIONS
 
 namespace detail {
@@ -182,31 +153,16 @@ namespace detail {
 template<int N, class T, bool IsConst>
 struct element_impl
 {
-private:
+  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
-  typedef typename T::tail_type Next;
+      apply<T>::type::head_type type;
-public:
-  typedef typename element_impl<N-1, Next, IsConst>::type type;
 };
 
 template<int N, class T>
 struct element_impl<N, T, true /* IsConst */>
 {
-private:
+  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
-  typedef typename T::tail_type Next;
+      apply<T>::type::head_type unqualified_type;
-public:
+  typedef const unqualified_type type;
-  typedef const typename element_impl<N-1, Next, true>::type type;
-};
-
-template<class T>
-struct element_impl<0, T, false /* IsConst */>
-{
-  typedef typename T::head_type type;
-};
-
-template<class T>
-struct element_impl<0, T, true /* IsConst */>
-{
-  typedef const typename T::head_type type;
 };
 
 } // end of namespace detail
@@ -257,18 +213,11 @@ template<int N, class HT, class TT>
 inline typename access_traits<
                   typename element<N, cons<HT, TT> >::type
                 >::non_const_type
-get(cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+get(cons<HT, TT>& c) {
-#if BOOST_WORKAROUND(__IBMCPP__,==600 )
+  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
-  return detail::get_class<N>::
+      apply<cons<HT, TT> > impl;
-#else
+  typedef BOOST_DEDUCED_TYPENAME impl::type cons_element;
-  return detail::get_class<N>::BOOST_NESTED_TEMPLATE
+  return const_cast<cons_element&>(impl::call(c)).head;
-#endif
-         get<
-           typename access_traits<
-             typename element<N, cons<HT, TT> >::type
-           >::non_const_type,
-           HT,TT
-         >(c);
 }
 
 // get function for const cons-lists, returns a const reference to
@@ -278,18 +227,10 @@ template<int N, class HT, class TT>
 inline typename access_traits<
                   typename element<N, cons<HT, TT> >::type
                 >::const_type
-get(const cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+get(const cons<HT, TT>& c) {
-#if BOOST_WORKAROUND(__IBMCPP__,==600)
+  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
-  return detail::get_class<N>::
+      apply<cons<HT, TT> > impl;
-#else
+  return impl::call(c).head;
-  return detail::get_class<N>::BOOST_NESTED_TEMPLATE
-#endif
-         get<
-           typename access_traits<
-             typename element<N, cons<HT, TT> >::type
-           >::const_type,
-           HT,TT
-         >(c);
 }
 
 // -- the cons template  --------------------------------------------------
@@ -462,7 +403,7 @@ struct cons<HT, null_type> {
   typename access_traits<
              typename element<N, self_type>::type
             >::non_const_type
-  get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+  get() {
     return boost::tuples::get<N>(*this);
   }
 
@@ -470,7 +411,7 @@ struct cons<HT, null_type> {
   typename access_traits<
              typename element<N, self_type>::type
            >::const_type
-  get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) const {
+  get() const {
     return boost::tuples::get<N>(*this);
   }
 
@@ -663,18 +604,21 @@ public:
 // Swallows any assignment   (by Doug Gregor)
 namespace detail {
 
+struct swallow_assign;
+typedef void (detail::swallow_assign::*ignore_t)();
 struct swallow_assign {
-
+  swallow_assign(ignore_t(*)(ignore_t)) {}
   template<typename T>
   swallow_assign const& operator=(const T&) const {
     return *this;
   }
 };
 
+
 } // namespace detail
 
 // "ignore" allows tuple positions to be ignored when using "tie".
-detail::swallow_assign const ignore = detail::swallow_assign();
+inline detail::ignore_t ignore(detail::ignore_t) { return 0; }
 
 // ---------------------------------------------------------------------------
 // The call_traits for make_tuple
@@ -756,6 +700,10 @@ struct make_tuple_traits<const reference_wrapper<T> >{
   typedef T& type;
 };
 
+template<>
+struct make_tuple_traits<detail::ignore_t(detail::ignore_t)> {
+  typedef detail::swallow_assign type;
+};
 
 
 
@@ -877,77 +825,165 @@ make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
   return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
 }
 
+namespace detail {
 
+template<class T>
+struct tie_traits {
+  typedef T& type;
+};
+
+template<>
+struct tie_traits<ignore_t(ignore_t)> {
+  typedef swallow_assign type;
+};
+
+template<>
+struct tie_traits<void> {
+  typedef null_type type;
+};
+
+template <
+  class T0 = void, class T1 = void, class T2 = void,
+  class T3 = void, class T4 = void, class T5 = void,
+  class T6 = void, class T7 = void, class T8 = void,
+  class T9 = void
+>
+struct tie_mapper {
+  typedef
+    tuple<typename tie_traits<T0>::type,
+          typename tie_traits<T1>::type,
+          typename tie_traits<T2>::type,
+          typename tie_traits<T3>::type,
+          typename tie_traits<T4>::type,
+          typename tie_traits<T5>::type,
+          typename tie_traits<T6>::type,
+          typename tie_traits<T7>::type,
+          typename tie_traits<T8>::type,
+          typename tie_traits<T9>::type> type;
+};
+
+}
 
 // Tie function templates -------------------------------------------------
-template<class T1>
+template<class T0>
-inline tuple<T1&> tie(T1& t1) {
+inline typename detail::tie_mapper<T0>::type
-  return tuple<T1&> (t1);
+tie(T0& t0) {
+  typedef typename detail::tie_mapper<T0>::type t;
+  return t(t0);
 }
 
-template<class T1, class T2>
+template<class T0, class T1>
-inline tuple<T1&, T2&> tie(T1& t1, T2& t2) {
+inline typename detail::tie_mapper<T0, T1>::type
-  return tuple<T1&, T2&> (t1, t2);
+tie(T0& t0, T1& t1) {
+  typedef typename detail::tie_mapper<T0, T1>::type t;
+  return t(t0, t1);
 }
 
-template<class T1, class T2, class T3>
+template<class T0, class T1, class T2>
-inline tuple<T1&, T2&, T3&> tie(T1& t1, T2& t2, T3& t3) {
+inline typename detail::tie_mapper<T0, T1, T2>::type
-  return tuple<T1&, T2&, T3&> (t1, t2, t3);
+tie(T0& t0, T1& t1, T2& t2) {
+  typedef typename detail::tie_mapper<T0, T1, T2>::type t;
+  return t(t0, t1, t2);
 }
 
-template<class T1, class T2, class T3, class T4>
+template<class T0, class T1, class T2, class T3>
-inline tuple<T1&, T2&, T3&, T4&> tie(T1& t1, T2& t2, T3& t3, T4& t4) {
+inline typename detail::tie_mapper<T0, T1, T2, T3>::type
-  return tuple<T1&, T2&, T3&, T4&> (t1, t2, t3, t4);
+tie(T0& t0, T1& t1, T2& t2, T3& t3) {
+  typedef typename detail::tie_mapper<T0, T1, T2, T3>::type t;
+  return t(t0, t1, t2, t3);
 }
 
-template<class T1, class T2, class T3, class T4, class T5>
+template<class T0, class T1, class T2, class T3, class T4>
-inline tuple<T1&, T2&, T3&, T4&, T5&>
+inline typename detail::tie_mapper<T0, T1, T2, T3, T4>::type
-tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) {
+tie(T0& t0, T1& t1, T2& t2, T3& t3,
-  return tuple<T1&, T2&, T3&, T4&, T5&> (t1, t2, t3, t4, t5);
+                  T4& t4) {
+  typedef typename detail::tie_mapper<T0, T1, T2, T3, T4>::type t;
+  return t(t0, t1, t2, t3, t4);
 }
 
-template<class T1, class T2, class T3, class T4, class T5, class T6>
+template<class T0, class T1, class T2, class T3, class T4, class T5>
-inline tuple<T1&, T2&, T3&, T4&, T5&, T6&>
+inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5>::type
-tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) {
+tie(T0& t0, T1& t1, T2& t2, T3& t3,
-  return tuple<T1&, T2&, T3&, T4&, T5&, T6&> (t1, t2, t3, t4, t5, t6);
+                  T4& t4, T5& t5) {
+  typedef typename detail::tie_mapper<T0, T1, T2, T3, T4, T5>::type t;
+  return t(t0, t1, t2, t3, t4, t5);
 }
 
-template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
-inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&>
+inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5, T6>::type
-tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) {
+tie(T0& t0, T1& t1, T2& t2, T3& t3,
-  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> (t1, t2, t3, t4, t5, t6, t7);
+                  T4& t4, T5& t5, T6& t6) {
+  typedef typename detail::tie_mapper
+           <T0, T1, T2, T3, T4, T5, T6>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6);
 }
 
-template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
-         class T8>
+         class T7>
-inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
+inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
-tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) {
+tie(T0& t0, T1& t1, T2& t2, T3& t3,
-  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
+                  T4& t4, T5& t5, T6& t6, T7& t7) {
-           (t1, t2, t3, t4, t5, t6, t7, t8);
+  typedef typename detail::tie_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6, t7);
 }
 
-template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
-         class T8, class T9>
+         class T7, class T8>
-inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
+inline typename detail::tie_mapper
-tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
+  <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
-           T9& t9) {
+tie(T0& t0, T1& t1, T2& t2, T3& t3,
-  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
+                  T4& t4, T5& t5, T6& t6, T7& t7,
-            (t1, t2, t3, t4, t5, t6, t7, t8, t9);
+                  T8& t8) {
+  typedef typename detail::tie_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
 }
 
-template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
-         class T8, class T9, class T10>
+         class T7, class T8, class T9>
-inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
+inline typename detail::tie_mapper
-tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
+  <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
-           T9& t9, T10& t10) {
+tie(T0& t0, T1& t1, T2& t2, T3& t3,
-  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
+                  T4& t4, T5& t5, T6& t6, T7& t7,
-           (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
+                  T8& t8, T9& t9) {
+  typedef typename detail::tie_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
+}
+
+template <class T0, class T1, class T2, class T3, class T4,
+          class T5, class T6, class T7, class T8, class T9>
+void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
+          tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs);
+inline void swap(null_type&, null_type&) {}
+template<class HH>
+inline void swap(cons<HH, null_type>& lhs, cons<HH, null_type>& rhs) {
+  ::boost::swap(lhs.head, rhs.head);
+}
+template<class HH, class TT>
+inline void swap(cons<HH, TT>& lhs, cons<HH, TT>& rhs) {
+  ::boost::swap(lhs.head, rhs.head);
+  ::boost::tuples::swap(lhs.tail, rhs.tail);
+}
+template <class T0, class T1, class T2, class T3, class T4,
+          class T5, class T6, class T7, class T8, class T9>
+inline void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
+          tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs) {
+  typedef tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> tuple_type;
+  typedef typename tuple_type::inherited base;
+  ::boost::tuples::swap(static_cast<base&>(lhs), static_cast<base&>(rhs));
 }
 
 } // end of namespace tuples
 } // end of namespace boost
 
 
+#if BOOST_GCC >= 40700
+#pragma GCC diagnostic pop
+#endif
+
+
 #endif // BOOST_TUPLE_BASIC_HPP
 
 

include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp

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

include/boost/tuple/tuple.hpp

@@ -23,16 +23,10 @@ namespace boost { namespace python { class tuple; }}
 #include "boost/config.hpp"
 #include "boost/static_assert.hpp"
 
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-// The MSVC version
-#include "boost/tuple/detail/tuple_basic_no_partial_spec.hpp"
-
-#else
 // other compilers
 #include "boost/ref.hpp"
 #include "boost/tuple/detail/tuple_basic.hpp"
 
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 namespace boost {    
 
@@ -41,7 +35,7 @@ using tuples::make_tuple;
 using tuples::tie;
 #if !defined(BOOST_NO_USING_TEMPLATE)
 using tuples::get;
-#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#else
 //
 // The "using tuples::get" statement causes the
 // Borland compiler to ICE, use forwarding
@@ -64,24 +58,7 @@ inline typename tuples::access_traits<
 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

include/boost/tuple/tuple_io.hpp

@@ -13,21 +13,10 @@
 #ifndef BOOST_TUPLE_IO_HPP
 #define BOOST_TUPLE_IO_HPP
 
-
-// add to boost/config.hpp
-// for now
-# if defined __GNUC__
-#   if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97) 
-#define BOOST_NO_TEMPLATED_STREAMS
-#endif
-#endif // __GNUC__
-
-#if defined BOOST_NO_TEMPLATED_STREAMS
-#include <iostream>
-#else 
 #include <istream>
 #include <ostream>
-#endif  
+
+#include <sstream>
 
 #include "boost/tuple/tuple.hpp"
 
@@ -74,25 +63,6 @@ private:
 
 public:
 
-#if defined (BOOST_NO_TEMPLATED_STREAMS)
-   static char get_manipulator(std::ios& i, manipulator_type m) {
-     char c = static_cast<char>(i.iword(get_stream_index(m))); 
-     
-     // parentheses and space are the default manipulators
-     if (!c) {
-       switch(m) {
-         case detail::format_info::open : c = '('; break;
-         case detail::format_info::close : c = ')'; break;
-         case detail::format_info::delimiter : c = ' '; break;
-       }
-     }
-     return c;
-   }
-
-   static void set_manipulator(std::ios& i, manipulator_type m, char c) {
-      i.iword(get_stream_index(m)) = static_cast<long>(c);
-   }
-#else
    template<class CharType, class CharTrait>
    static CharType get_manipulator(std::basic_ios<CharType, CharTrait>& i, 
                                    manipulator_type m) {
@@ -122,7 +92,6 @@ public:
      // convertible long.
       i.iword(get_stream_index(m)) = static_cast<long>(c);
    }
-#endif // BOOST_NO_TEMPLATED_STREAMS
 };
 
 } // end of namespace detail
@@ -136,39 +105,12 @@ public:
                              const char c = 0)
      : mt(m), f_c(c) {}
   
-#if defined (BOOST_NO_TEMPLATED_STREAMS)
-  void set(std::ios &io) const {
-     detail::format_info::set_manipulator(io, mt, f_c);
-  }
-#else
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-   template<class CharType2, class CharTrait>
-  void set(std::basic_ios<CharType2, CharTrait> &io) const {
-     detail::format_info::set_manipulator(io, mt, f_c);
-  }
-#else
    template<class CharTrait>
   void set(std::basic_ios<CharType, CharTrait> &io) const {
      detail::format_info::set_manipulator(io, mt, f_c);
   }
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#endif // BOOST_NO_TEMPLATED_STREAMS
 };
 
-#if defined (BOOST_NO_TEMPLATED_STREAMS)
-inline std::ostream&
-operator<<(std::ostream& o, const tuple_manipulator<char>& m) {
-  m.set(o);
-  return o;
-}
-
-inline std::istream&
-operator>>(std::istream& i, const tuple_manipulator<char>& m) {
-  m.set(i);
-  return i;
-}
-
-#else
 
 template<class CharType, class CharTrait>
 inline std::basic_ostream<CharType, CharTrait>&
@@ -184,7 +126,6 @@ operator>>(std::basic_istream<CharType, CharTrait>& i, const tuple_manipulator<C
   return i;
 }
 
-#endif   // BOOST_NO_TEMPLATED_STREAMS
    
 template<class CharType>
 inline tuple_manipulator<CharType> set_open(const CharType c) {
@@ -215,46 +156,12 @@ namespace detail {
 // Note: The order of the print functions is critical 
 // to let a conforming compiler  find and select the correct one.
 
-#if defined (BOOST_NO_TEMPLATED_STREAMS)
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-template<class T1>
-inline std::ostream& print(std::ostream& o, const cons<T1, null_type>& t) {
-  return o << t.head;
-}
-#endif // BOOST_NO_TEMPLATED_STREAMS
- 
-inline std::ostream& print(std::ostream& o, const null_type&) { return o; }
-
-template<class T1, class T2>
-inline std::ostream& 
-print(std::ostream& o, const cons<T1, T2>& t) {
-  
-  const char d = format_info::get_manipulator(o, format_info::delimiter);
-   
-  o << t.head;
-
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  if (tuples::length<T2>::value == 0)
-    return o;
-#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-  o << d;
-  
-  return print(o, t.tail );
-
-}
-
-
-
-#else
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 template<class CharType, class CharTrait, class T1>
 inline std::basic_ostream<CharType, CharTrait>& 
 print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, null_type>& t) {
   return o << t.head;
 }
-#endif  // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
  
 template<class CharType, class CharTrait>
@@ -271,60 +178,38 @@ print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, T2>& t) {
    
   o << t.head;
 
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  if (tuples::length<T2>::value == 0)
-    return o;
-#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   o << d;
 
   return print(o, t.tail);
 }
 
-#endif  // BOOST_NO_TEMPLATED_STREAMS
+template<class CharT, class Traits, class T>
+inline bool handle_width(std::basic_ostream<CharT, Traits>& o, const T& t) {
+    std::streamsize width = o.width();
+    if(width == 0) return false;
+
+    std::basic_ostringstream<CharT, Traits> ss;
+
+    ss.copyfmt(o);
+    ss.tie(0);
+    ss.width(0);
+
+    ss << t;
+    o << ss.str();
+
+    return true;
+}
+
 
 } // namespace detail
 
-#if defined (BOOST_NO_TEMPLATED_STREAMS)
-
-inline std::ostream& operator<<(std::ostream& o, const null_type& t) {
-  if (!o.good() ) return o;
- 
-  const char l = 
-    detail::format_info::get_manipulator(o, detail::format_info::open);
-  const char r = 
-    detail::format_info::get_manipulator(o, detail::format_info::close);
-   
-  o << l;
-  o << r;
-
-  return o;
-}
-
-template<class T1, class T2>
-inline std::ostream& operator<<(std::ostream& o, const cons<T1, T2>& t) {
-  if (!o.good() ) return o;
- 
-  const char l = 
-    detail::format_info::get_manipulator(o, detail::format_info::open);
-  const char r = 
-    detail::format_info::get_manipulator(o, detail::format_info::close);
-   
-  o << l;
-  
-  detail::print(o, t);  
-
-  o << r;
-
-  return o;
-}
-
-#else
 
 template<class CharType, class CharTrait>
 inline std::basic_ostream<CharType, CharTrait>& 
 operator<<(std::basic_ostream<CharType, CharTrait>& o, 
            const null_type& t) {
   if (!o.good() ) return o;
+  if (detail::handle_width(o, t)) return o;
  
   const CharType l = 
     detail::format_info::get_manipulator(o, detail::format_info::open);
@@ -342,6 +227,7 @@ inline std::basic_ostream<CharType, CharTrait>&
 operator<<(std::basic_ostream<CharType, CharTrait>& o, 
            const cons<T1, T2>& t) {
   if (!o.good() ) return o;
+  if (detail::handle_width(o, t)) return o;
  
   const CharType l = 
     detail::format_info::get_manipulator(o, detail::format_info::open);
@@ -356,7 +242,6 @@ operator<<(std::basic_ostream<CharType, CharTrait>& o,
 
   return o;
 }
-#endif // BOOST_NO_TEMPLATED_STREAMS
 
    
 // -------------------------------------------------------------
@@ -364,97 +249,6 @@ operator<<(std::basic_ostream<CharType, CharTrait>& o,
 
 namespace detail {
 
-#if defined (BOOST_NO_TEMPLATED_STREAMS)
-
-inline std::istream& 
-extract_and_check_delimiter(
-  std::istream& is, format_info::manipulator_type del)
-{
-  const char d = format_info::get_manipulator(is, del);
-
-#if defined (BOOST_NO_STD_LOCALE)
-  const bool is_delimiter = !isspace(d);
-#else
-  const bool is_delimiter = (!std::isspace(d, is.getloc()) );            
-#endif
-
-  char c;
-  if (is_delimiter) { 
-    is >> c; 
-    if (is.good() && c!=d) {
-      is.setstate(std::ios::failbit);
-    } 
-  }
-  return is;
-}
-
-
-// Note: The order of the read functions is critical to let a 
-// (conforming?) compiler find and select the correct one.
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-template<class T1>
-inline  std::istream & 
-read (std::istream &is, cons<T1, null_type>& t1) {
-
-  if (!is.good()) return is;   
-   
-  return is >> t1.head ;
-}
-#else
-inline std::istream& read(std::istream& i, const null_type&) { return i; }
-#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   
-template<class T1, class T2>
-inline std::istream& 
-read(std::istream &is, cons<T1, T2>& t1) {
-
-  if (!is.good()) return is;
-   
-  is >> t1.head;
-
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  if (tuples::length<T2>::value == 0)
-    return is;
-#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-  extract_and_check_delimiter(is, format_info::delimiter);
-
-  return read(is, t1.tail);
-}
-
-} // end namespace detail
-
-inline std::istream& 
-operator>>(std::istream &is, null_type&) {
-
-  if (!is.good() ) return is;
-
-  detail::extract_and_check_delimiter(is, detail::format_info::open);
-  detail::extract_and_check_delimiter(is, detail::format_info::close);
-
-  return is;
-}
-
-
-template<class T1, class T2>
-inline std::istream& 
-operator>>(std::istream& is, cons<T1, T2>& t1) {
-
-  if (!is.good() ) return is;
-
-  detail::extract_and_check_delimiter(is, detail::format_info::open);
-                      
-  detail::read(is, t1);
-   
-  detail::extract_and_check_delimiter(is, detail::format_info::close);
-
-  return is;
-}
-
-
-
-#else
 
 template<class CharType, class CharTrait>
 inline std::basic_istream<CharType, CharTrait>& 
@@ -478,12 +272,13 @@ extract_and_check_delimiter(
     if (is.good() && c!=d) { 
       is.setstate(std::ios::failbit);
     }
+  } else {
+    is >> std::ws;
   }
   return is;
 }
 
    
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 template<class CharType, class CharTrait, class T1>
 inline  std::basic_istream<CharType, CharTrait> & 
 read (std::basic_istream<CharType, CharTrait> &is, cons<T1, null_type>& t1) {
@@ -492,12 +287,6 @@ read (std::basic_istream<CharType, CharTrait> &is, cons<T1, null_type>& t1) {
    
   return is >> t1.head; 
 }
-#else
-template<class CharType, class CharTrait>
-inline std::basic_istream<CharType, CharTrait>& 
-read(std::basic_istream<CharType, CharTrait>& i, const null_type&) { return i; }
-
-#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 template<class CharType, class CharTrait, class T1, class T2>
 inline std::basic_istream<CharType, CharTrait>& 
@@ -507,10 +296,6 @@ read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) {
    
   is >> t1.head;
 
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  if (tuples::length<T2>::value == 0)
-    return is;
-#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
   extract_and_check_delimiter(is, format_info::delimiter);
 
@@ -547,7 +332,6 @@ operator>>(std::basic_istream<CharType, CharTrait>& is, cons<T1, T2>& t1) {
   return is;
 }
 
-#endif // BOOST_NO_TEMPLATED_STREAMS
 
 } // end of namespace tuples
 } // end of namespace boost

test/io_test.cpp

@@ -20,6 +20,7 @@
 #include <iterator>
 #include <algorithm>
 #include <string>
+#include <iomanip>
 
 #if defined BOOST_NO_STRINGSTREAM
 #include <strstream>
@@ -77,6 +78,11 @@ int test_main(int argc, char * argv[] ) {
   os3 << set_close(']');
   os3 << make_tuple();
   BOOST_CHECK (os3.str() == std::string("()[]") );
+  
+  // check width
+  useThisOStringStream os4;
+  os4 << std::setw(10) << make_tuple(1, 2, 3);
+  BOOST_CHECK (os4.str() == std::string("   (1 2 3)") );
 
   std::ofstream tmp("temp.tmp");
 
@@ -120,6 +126,13 @@ int test_main(int argc, char * argv[] ) {
   is3 >> set_close(']');
   BOOST_CHECK(bool(is3 >> ti2));
 
+  // Make sure that whitespace between elements
+  // is skipped.
+  useThisIStringStream is4("(100 200 300)"); 
+   
+  BOOST_CHECK(bool(is4 >> std::noskipws >> ti1));
+  BOOST_CHECK(ti1 == 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

test/tuple_test_bench.cpp

@@ -445,6 +445,26 @@ void tuple_length_test()
 
 }
 
+// ----------------------------------------------------------------------------
+// - testing swap -----------------------------------------------------------
+// ----------------------------------------------------------------------------
+void tuple_swap_test()
+{
+  tuple<int, float, double> t1(1, 2.0f, 3.0), t2(4, 5.0f, 6.0);
+  swap(t1, t2);
+  BOOST_CHECK(get<0>(t1) == 4);
+  BOOST_CHECK(get<1>(t1) == 5.0f);
+  BOOST_CHECK(get<2>(t1) == 6.0);
+  BOOST_CHECK(get<0>(t2) == 1);
+  BOOST_CHECK(get<1>(t2) == 2.0f);
+  BOOST_CHECK(get<2>(t2) == 3.0);
+
+  int i = 1,j = 2;
+  boost::tuple<int&> t3(i), t4(j);
+  swap(t3, t4);
+  BOOST_CHECK(i == 2);
+  BOOST_CHECK(j == 1);
+}
 
 
 
@@ -465,6 +485,7 @@ int test_main(int, char *[]) {
   cons_test();
   const_tuple_test();
   tuple_length_test();
+  tuple_swap_test();
   return 0;
 }