Makefile.in: Regenerate.

2007-03-09  Douglas Gregor  <doug.gregor@gmail.com>

	* include/Makefile.in: Regenerate.
	* include/tr1/mu_iterate.h: Remove.
	* include/tr1/tuple (_Tuple_impl): New.
	(tuple): Make variadic, re-implement as shell over _Tuple_impl.
	(0-element tuple): Basis case.
	(2-element tuple): Handle pair methods.
	(__get_helper): Remove.
	(tuple_element): Reimplement with variadic templates.
	(tuple_size): Ditto.
	(get): Ditto.
	(operator==): Use variadic templates in the signature.
	(operator<): Ditto.
	(operator!=): Ditto.
	(operator>): Ditto.
	(operator<=): Ditto.
	(operator>=): Ditto.
	(__stripped_tuple_type): Remove; we've inlined its behavior.
	(make_tuple): Reimplement with variadic templates.
	(tie): Ditto.
	* include/tr1/tuple_iterate.h: Remove.
	* include/tr1/bind_repeat.h: Remove.
	* include/tr1/ref_wrap_iterate.h: Remove.
	* include/tr1/bind_iterate.h: Remove.
	* include/tr1/functional (_Weak_result_type): Add variadic
	partial specializations.
	(result_of): Ditto.
	(__invoke): Reimplement using variadic templates.
	(reference_wrapper): Reimplement operator() with variadic
	templates.
	(_Maybe_unary_or_binary_function): New.
	(_Mem_fn): Implement for member function pointers using variadic
	templates.
	(placeholders): Define 30 placeholders.
	(_Index_tuple): New.
	(_Build_index_tuple): New.
	(_No_tuple_element): New.
	(_Safe_tuple_element_impl): New.
	(_Safe_tuple_element): New.
	(_Mu): Reimplement with variadic templates, use
	_Safe_tuple_element instead of tuple_element.
	(_Bind): Reimplement with variadic templates and tuples.
	(_Bind_result): Ditto.
	(bind): Reimplement with variadic templates.
	(_Function_handler): Ditto.
	(function): Ditto.
	* include/tr1/functional_iterate.h: Remove.
	* include/tr1/repeat.h: Remove.
	* include/Makefile.am: Don't install removed headers.

From-SVN: r122790

1 files changed, 279 insertions, 38 deletions

diff --git a/libstdc++-v3/include/tr1/tuple b/libstdc++-v3/include/tr1/tuple
index ea1d9e2..96ba4b8 100644
--- a/libstdc++-v3/include/tr1/tuple
+++ b/libstdc++-v3/include/tr1/tuple
@@ -32,29 +32,21 @@
 */
 
 // Chris Jefferson <chris@bubblescope.net>
+// Variadic Templates support by Douglas Gregor <doug.gregor@gmail.com>
 
 #ifndef _TR1_TUPLE
 #define _TR1_TUPLE 1
 
+#pragma GCC system_header
+
 #include <tr1/utility>
 #include <tr1/ref_fwd.h>
+#include <bits/cpp_type_traits.h> // for __enable_if
 
 namespace std
 {
 _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 
- // An implementation specific class which is used in the tuple class
- // when the tuple is not maximum possible size.
- struct _NullClass { };
-
- /// Gives the type of the ith element of a given tuple type.
- template<int __i, typename _Tp>
-   struct tuple_element;
-
- /// Finds the size of a given tuple type.
- template<typename _Tp>
-   struct tuple_size;
-
  // Adds a const reference to a non-reference type.
  template<typename _Tp>
    struct __add_c_ref
@@ -73,37 +65,220 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
    struct __add_ref<_Tp&>
    { typedef _Tp& type; };
 
- // Class used in the implementation of get
- template<int __i, typename _Tp>
-   struct __get_helper;
+/**
+ * @if maint
+ * Contains the actual implementation of the @c tuple template, stored
+ * as a recursive inheritance hierarchy from the first element (most
+ * derived class) to the last (least derived class). The @c Idx
+ * parameter gives the 0-based index of the element stored at this
+ * point in the hierarchy; we use it to implement a constant-time
+ * get() operation.
+ * @endif
+ */
+ template<int _Idx, typename... _Elements>
+   struct _Tuple_impl; 
 
- // Returns a const reference to the ith element of a tuple.
- // Any const or non-const ref elements are returned with their original type.
+ /**
+  * @if maint
+  * Zero-element tuple implementation. This is the basis case for the 
+  * inheritance recursion.
+  * @endif maint
+  */
+ template<int _Idx>
+   struct _Tuple_impl<_Idx> { };
 
- // This class helps construct the various comparison operations on tuples
- template<int __check_equal_size, int __i, int __j, typename _Tp, typename _Up>
-   struct __tuple_compare;
+ /**
+  * @if maint
+  * Recursive tuple implementation. Here we store the @c Head element
+  * and derive from a @c Tuple_impl containing the remaining elements
+  * (which contains the @c Tail).
+  * @endif
+  */
+ template<int _Idx, typename _Head, typename... _Tail>
+   struct _Tuple_impl<_Idx, _Head, _Tail...>
+     : public _Tuple_impl<_Idx+1, _Tail...>
+   {
+     typedef _Tuple_impl<_Idx+1, _Tail...> _Inherited;
 
- // Helper which adds a reference to a type when given a reference_wrapper
- template<typename _Tp>
-   struct __strip_reference_wrapper
+     _Head _M_head;
+
+     _Inherited&       _M_tail()       { return *this; }
+     const _Inherited& _M_tail() const { return *this; }
+
+     _Tuple_impl() : _Inherited(), _M_head() { }
+
+     explicit 
+     _Tuple_impl(typename __add_c_ref<_Head>::type __head,
+                 typename __add_c_ref<_Tail>::type... __tail)
+       : _Inherited(__tail...), _M_head(__head) { }
+
+     template<typename... _UElements>
+       _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
+         : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
+
+     _Tuple_impl(const _Tuple_impl& __in)
+       : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
+     
+     template<typename... _UElements>
+     _Tuple_impl& operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
+     {
+       _M_head = __in._M_head;
+       _M_tail() = __in._M_tail();
+       return *this;
+     }
+
+     _Tuple_impl& operator=(const _Tuple_impl& __in)
+     {
+       _M_head = __in._M_head;
+       _M_tail() = __in._M_tail();
+       return *this;
+     }
+   };
+
+ template<typename... _Elements> 
+   class tuple : public _Tuple_impl<0, _Elements...>
    {
-       typedef _Tp __type;
+     typedef _Tuple_impl<0, _Elements...> _Inherited;
+
+   public:
+     tuple() : _Inherited() { }
+
+     explicit
+     tuple(typename __add_c_ref<_Elements>::type... __elements)
+       : _Inherited(__elements...) { }
+
+     template<typename... _UElements>
+       tuple(const tuple<_UElements...>& __in)
+         : _Inherited(__in) { }
+
+     tuple(const tuple& __in)
+         : _Inherited(__in) { }
+
+     template<typename... _UElements>
+       tuple& operator=(const tuple<_UElements...>& __in)
+       {
+         static_cast<_Inherited&>(*this) = __in;
+         return *this;
+       }
+
+     tuple& operator=(const tuple& __in)
+     {
+       static_cast<_Inherited&>(*this) = __in;
+       return *this;
+     }
    };
 
- template<typename _Tp>
-   struct __strip_reference_wrapper<reference_wrapper<_Tp> >
+ template<> class tuple<> { };
+
+ // 2-element tuple, with construction and assignment from a pair.
+ template<typename _T1, typename _T2>
+   class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
    {
-     typedef _Tp& __type;
+     typedef _Tuple_impl<0, _T1, _T2> _Inherited;
+
+   public:
+     tuple() : _Inherited() { }
+
+     explicit
+     tuple(typename __add_c_ref<_T1>::type __a1,
+           typename __add_c_ref<_T2>::type __a2)
+       : _Inherited(__a1, __a2) { }
+
+     template<typename _U1, typename _U2>
+       tuple(const tuple<_U1, _U2>& __in)
+         : _Inherited(__in) { }
+
+     tuple(const tuple& __in)
+         : _Inherited(__in) { }
+
+     template<typename _U1, typename _U2>
+       tuple(const pair<_U1, _U2>& __in)
+         : _Inherited(
+             _Tuple_impl<0, 
+                         typename __add_c_ref<_U1>::type,
+                         typename __add_c_ref<_U2>::type>(__in.first, 
+                                                          __in.second))
+       { 
+       }
+  
+     template<typename _U1, typename _U2>
+       tuple& operator=(const tuple<_U1, _U2>& __in)
+       {
+         static_cast<_Inherited&>(*this) = __in;
+         return *this;
+       }
+
+     tuple& operator=(const tuple& __in)
+     {
+       static_cast<_Inherited&>(*this) = __in;
+       return *this;
+     }
+
+     template<typename _U1, typename _U2>
+       tuple& operator=(const pair<_U1, _U2>& __in)
+     {
+       this->_M_head = __in.first;
+       this->_M_tail()._M_head = __in.second;
+       return *this;
+     }
    };
 
+
+ /// Gives the type of the ith element of a given tuple type.
+ template<int __i, typename _Tp>
+   struct tuple_element;
+
+ /**
+  * @if maint
+  * Recursive case for tuple_element: strip off the first element in
+  * the tuple and retrieve the (i-1)th element of the remaining tuple.
+  * @endif
+  */
+ template<int __i, typename _Head, typename... _Tail>
+   struct tuple_element<__i, tuple<_Head, _Tail...> >
+     : tuple_element<__i - 1, tuple<_Tail...> > { };
+
+ /**
+  * @if maint
+  * Basis case for tuple_element: The first element is the one we're seeking.
+  * @endif
+  */
+ template<typename _Head, typename... _Tail>
+   struct tuple_element<0, tuple<_Head, _Tail...> >
+   {
+     typedef _Head type;
+   };
+
+ /// Finds the size of a given tuple type.
  template<typename _Tp>
-   struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
+   struct tuple_size;
+
+  /// @brief class tuple_size
+ template<typename... _Elements>
+   struct tuple_size<tuple<_Elements...> >
    {
-       typedef _Tp& __type;
+     static const int value = sizeof...(_Elements);
    };
 
-  #include "tuple_defs.h"
+ // Returns a const reference to the ith element of a tuple.
+ // Any const or non-const ref elements are returned with their original type.
+ template<int __i, typename _Head, typename... _Tail>
+   inline typename __add_ref<_Head>::type
+     get(_Tuple_impl<__i, _Head, _Tail...>& __t)
+     {
+       return __t._M_head;
+     }
+
+ template<int __i, typename _Head, typename... _Tail>
+   inline typename __add_c_ref<_Head>::type
+     get(const _Tuple_impl<__i, _Head, _Tail...>& __t)
+     {
+       return __t._M_head;
+     }
+
+ // This class helps construct the various comparison operations on tuples
+ template<int __check_equal_size, int __i, int __j, typename _Tp, typename _Up>
+   struct __tuple_compare;
 
  template<int __i, int __j, typename _Tp, typename _Up>
    struct __tuple_compare<0, __i, __j, _Tp, _Up>
@@ -129,6 +304,80 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
      { return false; }
    };
 
+ template<typename... _TElements, typename... _UElements>
+ bool
+ operator==(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u)
+ {
+   typedef tuple<_TElements...> _Tp;
+   typedef tuple<_UElements...> _Up;
+   return __tuple_compare<tuple_size<_Tp>::value - tuple_size<_Tp>::value, 0,
+                          tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u);
+ }
+
+ template<typename... _TElements, typename... _UElements>
+ bool
+ operator<(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u)
+ {
+   typedef tuple<_TElements...> _Tp;
+   typedef tuple<_UElements...> _Up;
+   return __tuple_compare<tuple_size<_Tp>::value - tuple_size<_Tp>::value, 0,
+                          tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u);
+ }
+
+ template<typename... _TElements, typename... _UElements>
+ bool
+ operator!=(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u)
+ { return !(__t == __u); }
+
+ template<typename... _TElements, typename... _UElements>
+ bool
+ operator>(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u)
+ { return __u < __t; }
+
+ template<typename... _TElements, typename... _UElements>
+ bool
+ operator<=(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u)
+ { return !(__u < __t); }
+
+ template<typename... _TElements, typename... _UElements>
+ bool
+ operator>=(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u)
+ { return !(__t < __u); }
+
+ // Helper which adds a reference to a type when given a reference_wrapper
+ template<typename _Tp>
+   struct __strip_reference_wrapper
+   {
+       typedef _Tp __type;
+   };
+
+ template<typename _Tp>
+   struct __strip_reference_wrapper<reference_wrapper<_Tp> >
+   {
+     typedef _Tp& __type;
+   };
+
+ template<typename _Tp>
+   struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
+   {
+       typedef _Tp& __type;
+   };
+
+  template<typename... _Elements>
+    inline tuple<typename __strip_reference_wrapper<_Elements>::__type...>
+    make_tuple(_Elements... __args)
+    {
+      typedef tuple<typename __strip_reference_wrapper<_Elements>::__type...>
+        __result_type;
+      return __result_type(__args...);
+    }
+
+  template<typename... _Elements>
+    inline tuple<_Elements&...> tie(_Elements&... __args)
+    {
+      return tuple<_Elements&...>(__args...);
+    }
+
  // A class (and instance) which can be used in 'tie' when an element
  // of a tuple is not required
  struct swallow_assign
@@ -148,14 +397,6 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
 _GLIBCXX_END_NAMESPACE
 }
 
-#define _GLIBCXX_CAT(x,y) _GLIBCXX_CAT2(x,y)
-#define _GLIBCXX_CAT2(x,y) x##y
-#define _SHORT_REPEAT
-#define _GLIBCXX_REPEAT_HEADER <tr1/tuple_iterate.h>
-#include <tr1/repeat.h>
-#undef _GLIBCXX_REPEAT_HEADER
-#undef _SHORT_REPEAT
-
 #include <tr1/functional>
 
 #endif