Merge pull request #3 from boostorg/develop

Merge some changes to master.

include/boost/tuple/detail/tuple_basic.hpp

@@ -41,6 +41,11 @@
 
 #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 {
 
@@ -208,7 +213,7 @@ 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) {
   typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
       apply<cons<HT, TT> > impl;
   typedef BOOST_DEDUCED_TYPENAME impl::type cons_element;
@@ -222,10 +227,9 @@ 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) {
   typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
       apply<cons<HT, TT> > impl;
-  typedef BOOST_DEDUCED_TYPENAME impl::type cons_element;
   return impl::call(c).head;
 }
 
@@ -399,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);
   }
 
@@ -407,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);
   }
 
@@ -975,6 +979,11 @@ inline void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
 } // 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,865 +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 "boost/utility/swap.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();
-
-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));
-}
-
-} // 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,8 @@
 #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>
 
@@ -76,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) {
@@ -124,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
@@ -138,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>&
@@ -186,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) {
@@ -217,62 +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 );
-
-}
-
-template<class T>
-inline bool handle_width(std::ostream& o, const T& t) {
-    std::streamsize width = o.width();
-    if(width == 0) return false;
-
-    std::ostringstream ss;
-
-    ss.copyfmt(o);
-    ss.tie(0);
-    ss.width(0);
-
-    ss << t;
-    o << ss.str();
-
-    return true;
-}
-
-
-#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>
@@ -289,10 +178,6 @@ 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);
@@ -315,47 +200,9 @@ inline bool handle_width(std::basic_ostream<CharT, Traits>& o, const T& t) {
     return true;
 }
 
-#endif  // BOOST_NO_TEMPLATED_STREAMS
 
 } // namespace detail
 
-#if defined (BOOST_NO_TEMPLATED_STREAMS)
-
-inline std::ostream& operator<<(std::ostream& o, const null_type& t) {
-  if (!o.good() ) return o;
-  if (detail::handle_width(o, t)) 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;
-  if (detail::handle_width(o, t)) 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>& 
@@ -395,7 +242,6 @@ operator<<(std::basic_ostream<CharType, CharTrait>& o,
 
   return o;
 }
-#endif // BOOST_NO_TEMPLATED_STREAMS
 
    
 // -------------------------------------------------------------
@@ -403,99 +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);
-    } 
-  } else {
-    is >> std::ws;
-  }
-  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>& 
@@ -526,7 +279,6 @@ extract_and_check_delimiter(
 }
 
    
-#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) {
@@ -535,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>& 
@@ -550,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);
 
@@ -590,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