Add index access support to base::Tuple

base/tuple.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // A Tuple is a generic templatized container, similar in concept to std::pair.
-// There are classes Tuple0 to Tuple6, cooresponding to the number of elements
-// it contains.  The convenient MakeTuple() function takes 0 to 6 arguments,
+// There are classes Tuple0 to Tuple8, cooresponding to the number of elements
+// it contains.  The convenient MakeTuple() function takes 0 to 8 arguments,
 // and will construct and return the appropriate Tuple object.  The functions
 // DispatchToMethod and DispatchToFunction take a function pointer or instance
 // and method pointer, and unpack a tuple into arguments to the call.
 //
 // Tuple elements are copied by value, and stored in the tuple.  See the unit
 // tests for more details of how/when the values are copied.
 //
 // Example usage:
 //   // These two methods of creating a Tuple are identical.
 //   Tuple2<int, const char*> tuple_a(1, "wee");
@@ skipping 29 matching lines @@
 };
 
 template <class P>
 struct TupleTraits<P&> {
   typedef P ValueType;
   typedef P& RefType;
   typedef P& ParamType;
 };
 
 template <class P>
-struct TupleTypes { };
+struct TupleTypes;
 
 // Tuple -----------------------------------------------------------------------
 //
 // This set of classes is useful for bundling 0 or more heterogeneous data types
 // into a single variable.  The advantage of this is that it greatly simplifies
 // function objects that need to take an arbitrary number of parameters; see
 // RunnableMethod and IPC::MessageWithTuple.
 //
 // Tuple0 is supplied to act as a 'void' type.  It can be used, for example,
 // when dispatching to a function that accepts no arguments (see the
 // Dispatchers below).
 // Tuple1<A> is rarely useful.  One such use is when A is non-const ref that you
 // want filled by the dispatchee, and the tuple is merely a container for that
 // output (a "tier").  See MakeRefTuple and its usages.
 
-struct Tuple0 {
-  typedef Tuple0 ValueTuple;
-  typedef Tuple0 RefTuple;
-  typedef Tuple0 ParamTuple;
+struct Tuple0;
+
+template <typename A>
+struct Tuple1;
+
+template <typename A, typename B>
+struct Tuple2;
+
+template <typename A, typename B, typename C>
+struct Tuple3;
+
+template <typename A, typename B, typename C, typename D>
+struct Tuple4;
+
+template <typename A, typename B, typename C, typename D, typename E>
+struct Tuple5;
+
+template <typename A, typename B, typename C, typename D, typename E,
+          typename F>
+struct Tuple6;
+
+template <typename A, typename B, typename C, typename D, typename E,
+          typename F, typename G>
+struct Tuple7;
+
+template <typename A, typename B, typename C, typename D, typename E,
+          typename F, typename G, typename H>
+struct Tuple8;
+
+namespace internal {
+
+template <typename... T>
+struct MakeTupleType;
+
+template <>
+struct MakeTupleType<> {
+  typedef Tuple0 Type;
+};
+
+template <typename A>
+struct MakeTupleType<A> {
+  typedef Tuple1<A> Type;
+};
+
+template <typename A, typename B>
+struct MakeTupleType<A, B> {
+  typedef Tuple2<A, B> Type;
+};
+
+template <typename A, typename B, typename C>
+struct MakeTupleType<A, B, C> {
+  typedef Tuple3<A, B, C> Type;
+};
+
+template <typename A, typename B, typename C, typename D>
+struct MakeTupleType<A, B, C, D> {
+  typedef Tuple4<A, B, C, D> Type;
+};
+
+template <typename A, typename B, typename C, typename D, typename E>
+struct MakeTupleType<A, B, C, D, E> {
+  typedef Tuple5<A, B, C, D, E> Type;
+};
+
+template <typename A, typename B, typename C, typename D, typename E,
+          typename F>
+struct MakeTupleType<A, B, C, D, E, F> {
+  typedef Tuple6<A, B, C, D, E, F> Type;
+};
+
+template <typename A, typename B, typename C, typename D, typename E,
+          typename F, typename G>
+struct MakeTupleType<A, B, C, D, E, F, G> {
+  typedef Tuple7<A, B, C, D, E, F, G> Type;
+};
+
+template <typename A, typename B, typename C, typename D, typename E,
+          typename F, typename G, typename H>
+struct MakeTupleType<A, B, C, D, E, F, G, H> {
+  typedef Tuple8<A, B, C, D, E, F, G, H> Type;
+};
+
+template <int index, typename TupleType>
+struct NthTupleItemImpl;
+
+template <typename TupleType>
+struct NthTupleItemImpl<0, TupleType> {
+  typedef typename TupleType::TypeA Type;
+  static Type& Get(TupleType* tuple) { return tuple->a; }
+  static const Type& Get(const TupleType* tuple) { return tuple->a; }
+};
+
+template <typename TupleType>
+struct NthTupleItemImpl<1, TupleType> {
+  typedef typename TupleType::TypeB Type;
+  static Type& Get(TupleType* tuple) { return tuple->b; }
+  static const Type& Get(const TupleType* tuple) { return tuple->b; }
+};
+
+template <typename TupleType>
+struct NthTupleItemImpl<2, TupleType> {
+  typedef typename TupleType::TypeC Type;
+  static Type& Get(TupleType* tuple) { return tuple->c; }
+  static const Type& Get(const TupleType* tuple) { return tuple->c; }
+};
+
+template <typename TupleType>
+struct NthTupleItemImpl<3, TupleType> {
+  typedef typename TupleType::TypeD Type;
+  static Type& Get(TupleType* tuple) { return tuple->d; }
+  static const Type& Get(const TupleType* tuple) { return tuple->d; }
+};
+
+template <typename TupleType>
+struct NthTupleItemImpl<4, TupleType> {
+  typedef typename TupleType::TypeE Type;
+  static Type& Get(TupleType* tuple) { return tuple->e; }
+  static const Type& Get(const TupleType* tuple) { return tuple->e; }
+};
+
+template <typename TupleType>
+struct NthTupleItemImpl<5, TupleType> {
+  typedef typename TupleType::TypeF Type;
+  static Type& Get(TupleType* tuple) { return tuple->f; }
+  static const Type& Get(const TupleType* tuple) { return tuple->f; }
+};
+
+template <typename TupleType>
+struct NthTupleItemImpl<6, TupleType> {
+  typedef typename TupleType::TypeG Type;
+  static Type& Get(TupleType* tuple) { return tuple->g; }
+  static const Type& Get(const TupleType* tuple) { return tuple->g; }
+};
+
+template <typename TupleType>
+struct NthTupleItemImpl<7, TupleType> {
+  typedef typename TupleType::TypeH Type;
+  static Type& Get(TupleType* tuple) { return tuple->h; }
+  static const Type& Get(const TupleType* tuple) { return tuple->h; }
+};
+
+}  // namespace internal
+
+template <typename... T>
+using Tuple = typename internal::MakeTupleType<T...>::Type;
+
+template <typename... T>
+struct TupleBase {
+  static const int size = sizeof...(T);
+  typedef Tuple<T...> TupleType;
+
+  template <int index>
+  using NthItemType = typename internal::NthTupleItemImpl<
+    index, TupleType>::Type;
+
+  template <int index>
+  NthItemType<index>& Get() {
+    static_assert(index < size, "Index out of bound");
+    return internal::NthTupleItemImpl<index, TupleType>::Get(
+        static_cast<TupleType*>(this));
+  }
+
+  template <int index>
+  const NthItemType<index>& Get() const {
+    static_assert(index < size, "Index out of bound");
+    return internal::NthTupleItemImpl<index, TupleType>::Get(
+        static_cast<const TupleType*>(this));
+  }
+};
+
+struct Tuple0 : TupleBase<> {
 };
 
 template <class A>
-struct Tuple1 {
- public:
+struct Tuple1 : TupleBase<A> {
   typedef A TypeA;
 
   Tuple1() {}
   explicit Tuple1(typename TupleTraits<A>::ParamType a) : a(a) {}
 
   A a;
 };
 
 template <class A, class B>
-struct Tuple2 {
- public:
+struct Tuple2 : TupleBase<A, B> {
   typedef A TypeA;
   typedef B TypeB;
 
   Tuple2() {}
   Tuple2(typename TupleTraits<A>::ParamType a,
          typename TupleTraits<B>::ParamType b)
       : a(a), b(b) {
   }
 
   A a;
   B b;
 };
 
 template <class A, class B, class C>
-struct Tuple3 {
- public:
+struct Tuple3 : TupleBase<A, B, C> {
   typedef A TypeA;
   typedef B TypeB;
   typedef C TypeC;
 
   Tuple3() {}
   Tuple3(typename TupleTraits<A>::ParamType a,
          typename TupleTraits<B>::ParamType b,
          typename TupleTraits<C>::ParamType c)
       : a(a), b(b), c(c){
   }
 
   A a;
   B b;
   C c;
 };
 
 template <class A, class B, class C, class D>
-struct Tuple4 {
- public:
+struct Tuple4 : TupleBase<A, B, C, D> {
   typedef A TypeA;
   typedef B TypeB;
   typedef C TypeC;
   typedef D TypeD;
 
   Tuple4() {}
   Tuple4(typename TupleTraits<A>::ParamType a,
          typename TupleTraits<B>::ParamType b,
          typename TupleTraits<C>::ParamType c,
          typename TupleTraits<D>::ParamType d)
       : a(a), b(b), c(c), d(d) {
   }
 
   A a;
   B b;
   C c;
   D d;
 };
 
 template <class A, class B, class C, class D, class E>
-struct Tuple5 {
- public:
+struct Tuple5 : TupleBase<A, B, C, D, E> {
   typedef A TypeA;
   typedef B TypeB;
   typedef C TypeC;
   typedef D TypeD;
   typedef E TypeE;
 
   Tuple5() {}
   Tuple5(typename TupleTraits<A>::ParamType a,
-    typename TupleTraits<B>::ParamType b,
-    typename TupleTraits<C>::ParamType c,
-    typename TupleTraits<D>::ParamType d,
-    typename TupleTraits<E>::ParamType e)
-    : a(a), b(b), c(c), d(d), e(e) {
+         typename TupleTraits<B>::ParamType b,
+         typename TupleTraits<C>::ParamType c,
+         typename TupleTraits<D>::ParamType d,
+         typename TupleTraits<E>::ParamType e)
+      : a(a), b(b), c(c), d(d), e(e) {
   }
 
   A a;
   B b;
   C c;
   D d;
   E e;
 };
 
 template <class A, class B, class C, class D, class E, class F>
-struct Tuple6 {
- public:
+struct Tuple6 : TupleBase<A, B, C, D, E, F> {
   typedef A TypeA;
   typedef B TypeB;
   typedef C TypeC;
   typedef D TypeD;
   typedef E TypeE;
   typedef F TypeF;
 
   Tuple6() {}
   Tuple6(typename TupleTraits<A>::ParamType a,
-    typename TupleTraits<B>::ParamType b,
-    typename TupleTraits<C>::ParamType c,
-    typename TupleTraits<D>::ParamType d,
-    typename TupleTraits<E>::ParamType e,
-    typename TupleTraits<F>::ParamType f)
-    : a(a), b(b), c(c), d(d), e(e), f(f) {
+         typename TupleTraits<B>::ParamType b,
+         typename TupleTraits<C>::ParamType c,
+         typename TupleTraits<D>::ParamType d,
+         typename TupleTraits<E>::ParamType e,
+         typename TupleTraits<F>::ParamType f)
+      : a(a), b(b), c(c), d(d), e(e), f(f) {
   }
 
   A a;
   B b;
   C c;
   D d;
   E e;
   F f;
 };
 
 template <class A, class B, class C, class D, class E, class F, class G>
-struct Tuple7 {
- public:
+struct Tuple7 : TupleBase<A, B, C, D, E, F, G> {
   typedef A TypeA;
   typedef B TypeB;
   typedef C TypeC;
   typedef D TypeD;
   typedef E TypeE;
   typedef F TypeF;
   typedef G TypeG;
 
   Tuple7() {}
   Tuple7(typename TupleTraits<A>::ParamType a,
-    typename TupleTraits<B>::ParamType b,
-    typename TupleTraits<C>::ParamType c,
-    typename TupleTraits<D>::ParamType d,
-    typename TupleTraits<E>::ParamType e,
-    typename TupleTraits<F>::ParamType f,
-    typename TupleTraits<G>::ParamType g)
-    : a(a), b(b), c(c), d(d), e(e), f(f), g(g) {
+         typename TupleTraits<B>::ParamType b,
+         typename TupleTraits<C>::ParamType c,
+         typename TupleTraits<D>::ParamType d,
+         typename TupleTraits<E>::ParamType e,
+         typename TupleTraits<F>::ParamType f,
+         typename TupleTraits<G>::ParamType g)
+      : a(a), b(b), c(c), d(d), e(e), f(f), g(g) {
   }
 
   A a;
   B b;
   C c;
   D d;
   E e;
   F f;
   G g;
 };
 
 template <class A, class B, class C, class D, class E, class F, class G,
           class H>
-struct Tuple8 {
- public:
+struct Tuple8 : TupleBase<A, B, C, D, E, F, G, H> {
   typedef A TypeA;
   typedef B TypeB;
   typedef C TypeC;
   typedef D TypeD;
   typedef E TypeE;
   typedef F TypeF;
   typedef G TypeG;
   typedef H TypeH;
 
   Tuple8() {}
   Tuple8(typename TupleTraits<A>::ParamType a,
-    typename TupleTraits<B>::ParamType b,
-    typename TupleTraits<C>::ParamType c,
-    typename TupleTraits<D>::ParamType d,
-    typename TupleTraits<E>::ParamType e,
-    typename TupleTraits<F>::ParamType f,
-    typename TupleTraits<G>::ParamType g,
-    typename TupleTraits<H>::ParamType h)
-    : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h) {
+         typename TupleTraits<B>::ParamType b,
+         typename TupleTraits<C>::ParamType c,
+         typename TupleTraits<D>::ParamType d,
+         typename TupleTraits<E>::ParamType e,
+         typename TupleTraits<F>::ParamType f,
+         typename TupleTraits<G>::ParamType g,
+         typename TupleTraits<H>::ParamType h)
+      : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h) {
   }
 
   A a;
   B b;
   C c;
   D d;
   E e;
   F f;
   G g;
   H h;
@@ skipping 15 matching lines @@
 struct TupleTypes< Tuple1<A> > {
   typedef Tuple1<typename TupleTraits<A>::ValueType> ValueTuple;
   typedef Tuple1<typename TupleTraits<A>::RefType> RefTuple;
   typedef Tuple1<typename TupleTraits<A>::ParamType> ParamTuple;
 };
 
 template <class A, class B>
 struct TupleTypes< Tuple2<A, B> > {
   typedef Tuple2<typename TupleTraits<A>::ValueType,
                  typename TupleTraits<B>::ValueType> ValueTuple;
-typedef Tuple2<typename TupleTraits<A>::RefType,
-               typename TupleTraits<B>::RefType> RefTuple;
+  typedef Tuple2<typename TupleTraits<A>::RefType,
+                 typename TupleTraits<B>::RefType> RefTuple;
   typedef Tuple2<typename TupleTraits<A>::ParamType,
                  typename TupleTraits<B>::ParamType> ParamTuple;
 };
 
 template <class A, class B, class C>
 struct TupleTypes< Tuple3<A, B, C> > {
   typedef Tuple3<typename TupleTraits<A>::ValueType,
                  typename TupleTraits<B>::ValueType,
                  typename TupleTraits<C>::ValueType> ValueTuple;
-typedef Tuple3<typename TupleTraits<A>::RefType,
-               typename TupleTraits<B>::RefType,
-               typename TupleTraits<C>::RefType> RefTuple;
+  typedef Tuple3<typename TupleTraits<A>::RefType,
+                 typename TupleTraits<B>::RefType,
+                 typename TupleTraits<C>::RefType> RefTuple;
   typedef Tuple3<typename TupleTraits<A>::ParamType,
                  typename TupleTraits<B>::ParamType,
                  typename TupleTraits<C>::ParamType> ParamTuple;
 };
 
 template <class A, class B, class C, class D>
 struct TupleTypes< Tuple4<A, B, C, D> > {
   typedef Tuple4<typename TupleTraits<A>::ValueType,
                  typename TupleTraits<B>::ValueType,
                  typename TupleTraits<C>::ValueType,
                  typename TupleTraits<D>::ValueType> ValueTuple;
-typedef Tuple4<typename TupleTraits<A>::RefType,
-               typename TupleTraits<B>::RefType,
-               typename TupleTraits<C>::RefType,
-               typename TupleTraits<D>::RefType> RefTuple;
+  typedef Tuple4<typename TupleTraits<A>::RefType,
+                 typename TupleTraits<B>::RefType,
+                 typename TupleTraits<C>::RefType,
+                 typename TupleTraits<D>::RefType> RefTuple;
   typedef Tuple4<typename TupleTraits<A>::ParamType,
                  typename TupleTraits<B>::ParamType,
                  typename TupleTraits<C>::ParamType,
                  typename TupleTraits<D>::ParamType> ParamTuple;
 };
 
 template <class A, class B, class C, class D, class E>
 struct TupleTypes< Tuple5<A, B, C, D, E> > {
   typedef Tuple5<typename TupleTraits<A>::ValueType,
                  typename TupleTraits<B>::ValueType,
                  typename TupleTraits<C>::ValueType,
                  typename TupleTraits<D>::ValueType,
                  typename TupleTraits<E>::ValueType> ValueTuple;
-typedef Tuple5<typename TupleTraits<A>::RefType,
-               typename TupleTraits<B>::RefType,
-               typename TupleTraits<C>::RefType,
-               typename TupleTraits<D>::RefType,
-               typename TupleTraits<E>::RefType> RefTuple;
+  typedef Tuple5<typename TupleTraits<A>::RefType,
+                 typename TupleTraits<B>::RefType,
+                 typename TupleTraits<C>::RefType,
+                 typename TupleTraits<D>::RefType,
+                 typename TupleTraits<E>::RefType> RefTuple;
   typedef Tuple5<typename TupleTraits<A>::ParamType,
                  typename TupleTraits<B>::ParamType,
                  typename TupleTraits<C>::ParamType,
                  typename TupleTraits<D>::ParamType,
                  typename TupleTraits<E>::ParamType> ParamTuple;
 };
 
 template <class A, class B, class C, class D, class E, class F>
 struct TupleTypes< Tuple6<A, B, C, D, E, F> > {
   typedef Tuple6<typename TupleTraits<A>::ValueType,
                  typename TupleTraits<B>::ValueType,
                  typename TupleTraits<C>::ValueType,
                  typename TupleTraits<D>::ValueType,
                  typename TupleTraits<E>::ValueType,
                  typename TupleTraits<F>::ValueType> ValueTuple;
-typedef Tuple6<typename TupleTraits<A>::RefType,
-               typename TupleTraits<B>::RefType,
-               typename TupleTraits<C>::RefType,
-               typename TupleTraits<D>::RefType,
-               typename TupleTraits<E>::RefType,
-               typename TupleTraits<F>::RefType> RefTuple;
+  typedef Tuple6<typename TupleTraits<A>::RefType,
+                 typename TupleTraits<B>::RefType,
+                 typename TupleTraits<C>::RefType,
+                 typename TupleTraits<D>::RefType,
+                 typename TupleTraits<E>::RefType,
+                 typename TupleTraits<F>::RefType> RefTuple;
   typedef Tuple6<typename TupleTraits<A>::ParamType,
                  typename TupleTraits<B>::ParamType,
                  typename TupleTraits<C>::ParamType,
                  typename TupleTraits<D>::ParamType,
                  typename TupleTraits<E>::ParamType,
                  typename TupleTraits<F>::ParamType> ParamTuple;
 };
 
 template <class A, class B, class C, class D, class E, class F, class G>
 struct TupleTypes< Tuple7<A, B, C, D, E, F, G> > {
   typedef Tuple7<typename TupleTraits<A>::ValueType,
                  typename TupleTraits<B>::ValueType,
                  typename TupleTraits<C>::ValueType,
                  typename TupleTraits<D>::ValueType,
                  typename TupleTraits<E>::ValueType,
                  typename TupleTraits<F>::ValueType,
                  typename TupleTraits<G>::ValueType> ValueTuple;
-typedef Tuple7<typename TupleTraits<A>::RefType,
-               typename TupleTraits<B>::RefType,
-               typename TupleTraits<C>::RefType,
-               typename TupleTraits<D>::RefType,
-               typename TupleTraits<E>::RefType,
-               typename TupleTraits<F>::RefType,
-               typename TupleTraits<G>::RefType> RefTuple;
+  typedef Tuple7<typename TupleTraits<A>::RefType,
+                 typename TupleTraits<B>::RefType,
+                 typename TupleTraits<C>::RefType,
+                 typename TupleTraits<D>::RefType,
+                 typename TupleTraits<E>::RefType,
+                 typename TupleTraits<F>::RefType,
+                 typename TupleTraits<G>::RefType> RefTuple;
   typedef Tuple7<typename TupleTraits<A>::ParamType,
                  typename TupleTraits<B>::ParamType,
                  typename TupleTraits<C>::ParamType,
                  typename TupleTraits<D>::ParamType,
                  typename TupleTraits<E>::ParamType,
                  typename TupleTraits<F>::ParamType,
                  typename TupleTraits<G>::ParamType> ParamTuple;
 };
 
 template <class A, class B, class C, class D, class E, class F, class G,
           class H>
 struct TupleTypes< Tuple8<A, B, C, D, E, F, G, H> > {
   typedef Tuple8<typename TupleTraits<A>::ValueType,
                  typename TupleTraits<B>::ValueType,
                  typename TupleTraits<C>::ValueType,
                  typename TupleTraits<D>::ValueType,
                  typename TupleTraits<E>::ValueType,
                  typename TupleTraits<F>::ValueType,
                  typename TupleTraits<G>::ValueType,
                  typename TupleTraits<H>::ValueType> ValueTuple;
-typedef Tuple8<typename TupleTraits<A>::RefType,
-               typename TupleTraits<B>::RefType,
-               typename TupleTraits<C>::RefType,
-               typename TupleTraits<D>::RefType,
-               typename TupleTraits<E>::RefType,
-               typename TupleTraits<F>::RefType,
-               typename TupleTraits<G>::RefType,
-               typename TupleTraits<H>::RefType> RefTuple;
+  typedef Tuple8<typename TupleTraits<A>::RefType,
+                 typename TupleTraits<B>::RefType,
+                 typename TupleTraits<C>::RefType,
+                 typename TupleTraits<D>::RefType,
+                 typename TupleTraits<E>::RefType,
+                 typename TupleTraits<F>::RefType,
+                 typename TupleTraits<G>::RefType,
+                 typename TupleTraits<H>::RefType> RefTuple;
   typedef Tuple8<typename TupleTraits<A>::ParamType,
                  typename TupleTraits<B>::ParamType,
                  typename TupleTraits<C>::ParamType,
                  typename TupleTraits<D>::ParamType,
                  typename TupleTraits<E>::ParamType,
                  typename TupleTraits<F>::ParamType,
                  typename TupleTraits<G>::ParamType,
                  typename TupleTraits<H>::ParamType> ParamTuple;
 };
 
 // Tuple creators -------------------------------------------------------------
 //
-// Helper functions for constructing tuples while inferring the template
+// Helper function for constructing tuples while inferring the template
 // argument types.
-
-inline Tuple0 MakeTuple() {
-  return Tuple0();
+template <typename... T>
+inline Tuple<T...> MakeTuple(const T&... p) {
+  return Tuple<T...>(p...);
 }
 
-template <class A>
-inline Tuple1<A> MakeTuple(const A& a) {
-  return Tuple1<A>(a);
-}
-
-template <class A, class B>
-inline Tuple2<A, B> MakeTuple(const A& a, const B& b) {
-  return Tuple2<A, B>(a, b);
-}
-
-template <class A, class B, class C>
-inline Tuple3<A, B, C> MakeTuple(const A& a, const B& b, const C& c) {
-  return Tuple3<A, B, C>(a, b, c);
-}
-
-template <class A, class B, class C, class D>
-inline Tuple4<A, B, C, D> MakeTuple(const A& a, const B& b, const C& c,
-                                    const D& d) {
-  return Tuple4<A, B, C, D>(a, b, c, d);
-}
-
-template <class A, class B, class C, class D, class E>
-inline Tuple5<A, B, C, D, E> MakeTuple(const A& a, const B& b, const C& c,
-                                       const D& d, const E& e) {
-  return Tuple5<A, B, C, D, E>(a, b, c, d, e);
-}
-
-template <class A, class B, class C, class D, class E, class F>
-inline Tuple6<A, B, C, D, E, F> MakeTuple(const A& a, const B& b, const C& c,
-                                          const D& d, const E& e, const F& f) {
-  return Tuple6<A, B, C, D, E, F>(a, b, c, d, e, f);
-}
-
-template <class A, class B, class C, class D, class E, class F, class G>
-inline Tuple7<A, B, C, D, E, F, G> MakeTuple(const A& a, const B& b, const C& c,
-                                             const D& d, const E& e, const F& f,
-                                             const G& g) {
-  return Tuple7<A, B, C, D, E, F, G>(a, b, c, d, e, f, g);
-}
-
-template <class A, class B, class C, class D, class E, class F, class G,
-          class H>
-inline Tuple8<A, B, C, D, E, F, G, H> MakeTuple(const A& a, const B& b,
-                                                const C& c, const D& d,
-                                                const E& e, const F& f,
-                                                const G& g, const H& h) {
-  return Tuple8<A, B, C, D, E, F, G, H>(a, b, c, d, e, f, g, h);
-}
-
-// The following set of helpers make what Boost refers to as "Tiers" - a tuple
+// The following helper make what Boost refers to as "Tiers" - a tuple
 // of references.
-
-template <class A>
-inline Tuple1<A&> MakeRefTuple(A& a) {
-  return Tuple1<A&>(a);
-}
-
-template <class A, class B>
-inline Tuple2<A&, B&> MakeRefTuple(A& a, B& b) {
-  return Tuple2<A&, B&>(a, b);
-}
-
-template <class A, class B, class C>
-inline Tuple3<A&, B&, C&> MakeRefTuple(A& a, B& b, C& c) {
-  return Tuple3<A&, B&, C&>(a, b, c);
-}
-
-template <class A, class B, class C, class D>
-inline Tuple4<A&, B&, C&, D&> MakeRefTuple(A& a, B& b, C& c, D& d) {
-  return Tuple4<A&, B&, C&, D&>(a, b, c, d);
-}
-
-template <class A, class B, class C, class D, class E>
-inline Tuple5<A&, B&, C&, D&, E&> MakeRefTuple(A& a, B& b, C& c, D& d, E& e) {
-  return Tuple5<A&, B&, C&, D&, E&>(a, b, c, d, e);
-}
-
-template <class A, class B, class C, class D, class E, class F>
-inline Tuple6<A&, B&, C&, D&, E&, F&> MakeRefTuple(A& a, B& b, C& c, D& d, E& e,
-                                                   F& f) {
-  return Tuple6<A&, B&, C&, D&, E&, F&>(a, b, c, d, e, f);
-}
-
-template <class A, class B, class C, class D, class E, class F, class G>
-inline Tuple7<A&, B&, C&, D&, E&, F&, G&> MakeRefTuple(A& a, B& b, C& c, D& d,
-                                                       E& e, F& f, G& g) {
-  return Tuple7<A&, B&, C&, D&, E&, F&, G&>(a, b, c, d, e, f, g);
-}
-
-template <class A, class B, class C, class D, class E, class F, class G,
-          class H>
-inline Tuple8<A&, B&, C&, D&, E&, F&, G&, H&> MakeRefTuple(A& a, B& b, C& c,
-                                                           D& d, E& e, F& f,
-                                                           G& g, H& h) {
-  return Tuple8<A&, B&, C&, D&, E&, F&, G&, H&>(a, b, c, d, e, f, g, h);
+template <typename... T>
+inline Tuple<T&...> MakeRefTuple(T&... p) {
+  return Tuple<T&...>(p...);
 }
 
 // Dispatchers ----------------------------------------------------------------
 //
 // Helper functions that call the given method on an object, with the unpacked
 // tuple arguments.  Notice that they all have the same number of arguments,
 // so you need only write:
 //   DispatchToMethod(object, &Object::method, args);
 // This is very useful for templated dispatchers, since they don't need to know
 // what type |args| is.
 
 // Non-Static Dispatchers with no out params.
 
 template <class ObjT, class Method>
 inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& arg) {
   (obj->*method)();
 }
 
 template <class ObjT, class Method, class A>
-inline void DispatchToMethod(ObjT* obj, Method method, const A& arg) {
-  (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg));
-}
-
-template <class ObjT, class Method, class A>
 inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1<A>& arg) {
   (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a));
 }
 
 template<class ObjT, class Method, class A, class B>
 inline void DispatchToMethod(ObjT* obj,
                              Method method,
                              const Tuple2<A, B>& arg) {
   (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
                  base::internal::UnwrapTraits<B>::Unwrap(arg.b));
@@ skipping 66 matching lines @@
 }
 
 // Static Dispatchers with no out params.
 
 template <class Function>
 inline void DispatchToFunction(Function function, const Tuple0& arg) {
   (*function)();
 }
 
 template <class Function, class A>
-inline void DispatchToFunction(Function function, const A& arg) {
-  (*function)(arg);
-}
-
-template <class Function, class A>
 inline void DispatchToFunction(Function function, const Tuple1<A>& arg) {
   (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a));
 }
 
 template<class Function, class A, class B>
 inline void DispatchToFunction(Function function, const Tuple2<A, B>& arg) {
   (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
               base::internal::UnwrapTraits<B>::Unwrap(arg.b));
 }
 
@@ skipping 64 matching lines @@
 // Dispatchers with 0 out param (as a Tuple0).
 
 template <class ObjT, class Method>
 inline void DispatchToMethod(ObjT* obj,
                              Method method,
                              const Tuple0& arg, Tuple0*) {
   (obj->*method)();
 }
 
 template <class ObjT, class Method, class A>
-inline void DispatchToMethod(ObjT* obj, Method method, const A& arg, Tuple0*) {
-  (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg));
-}
-
-template <class ObjT, class Method, class A>
 inline void DispatchToMethod(ObjT* obj,
                              Method method,
                              const Tuple1<A>& arg, Tuple0*) {
   (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a));
 }
 
 template<class ObjT, class Method, class A, class B>
 inline void DispatchToMethod(ObjT* obj,
                              Method method,
                              const Tuple2<A, B>& arg, Tuple0*) {
@@ skipping 46 matching lines @@
          class OutA>
 inline void DispatchToMethod(ObjT* obj, Method method,
                              const Tuple0& in,
                              Tuple1<OutA>* out) {
   (obj->*method)(&out->a);
 }
 
 template<class ObjT, class Method, class InA,
          class OutA>
 inline void DispatchToMethod(ObjT* obj, Method method,
-                             const InA& in,
-                             Tuple1<OutA>* out) {
-  (obj->*method)(in, &out->a);
-}
-
-template<class ObjT, class Method, class InA,
-         class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
                              const Tuple1<InA>& in,
                              Tuple1<OutA>* out) {
   (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a), &out->a);
 }
 
 template<class ObjT, class Method, class InA, class InB,
          class OutA>
 inline void DispatchToMethod(ObjT* obj, Method method,
                              const Tuple2<InA, InB>& in,
                              Tuple1<OutA>* out) {
@@ skipping 59 matching lines @@
          class OutA, class OutB>
 inline void DispatchToMethod(ObjT* obj, Method method,
                              const Tuple0& in,
                              Tuple2<OutA, OutB>* out) {
   (obj->*method)(&out->a, &out->b);
 }
 
 template<class ObjT, class Method, class InA,
          class OutA, class OutB>
 inline void DispatchToMethod(ObjT* obj, Method method,
-                             const InA& in,
-                             Tuple2<OutA, OutB>* out) {
-  (obj->*method)(in, &out->a, &out->b);
-}
-
-template<class ObjT, class Method, class InA,
-         class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
                              const Tuple1<InA>& in,
                              Tuple2<OutA, OutB>* out) {
   (obj->*method)(
       base::internal::UnwrapTraits<InA>::Unwrap(in.a), &out->a, &out->b);
 }
 
 template<class ObjT, class Method, class InA, class InB,
          class OutA, class OutB>
 inline void DispatchToMethod(ObjT* obj, Method method,
                              const Tuple2<InA, InB>& in,
@@ skipping 66 matching lines @@
          class OutA, class OutB, class OutC>
 inline void DispatchToMethod(ObjT* obj, Method method,
                              const Tuple0& in,
                              Tuple3<OutA, OutB, OutC>* out) {
   (obj->*method)(&out->a, &out->b, &out->c);
 }
 
 template<class ObjT, class Method, class InA,
          class OutA, class OutB, class OutC>
 inline void DispatchToMethod(ObjT* obj, Method method,
-                             const InA& in,
-                             Tuple3<OutA, OutB, OutC>* out) {
-  (obj->*method)(in, &out->a, &out->b, &out->c);
-}
-
-template<class ObjT, class Method, class InA,
-         class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
                              const Tuple1<InA>& in,
                              Tuple3<OutA, OutB, OutC>* out) {
   (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
                  &out->a,
                  &out->b,
                  &out->c);
 }
 
 template<class ObjT, class Method, class InA, class InB,
          class OutA, class OutB, class OutC>
@@ skipping 73 matching lines @@
          class OutA, class OutB, class OutC, class OutD>
 inline void DispatchToMethod(ObjT* obj, Method method,
                              const Tuple0& in,
                              Tuple4<OutA, OutB, OutC, OutD>* out) {
   (obj->*method)(&out->a, &out->b, &out->c, &out->d);
 }
 
 template<class ObjT, class Method, class InA,
          class OutA, class OutB, class OutC, class OutD>
 inline void DispatchToMethod(ObjT* obj, Method method,
-                             const InA& in,
-                             Tuple4<OutA, OutB, OutC, OutD>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in),
-                 &out->a,
-                 &out->b,
-                 &out->c,
-                 &out->d);
-}
-
-template<class ObjT, class Method, class InA,
-         class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
                              const Tuple1<InA>& in,
                              Tuple4<OutA, OutB, OutC, OutD>* out) {
   (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
                  &out->a,
                  &out->b,
                  &out->c,
                  &out->d);
 }
 
 template<class ObjT, class Method, class InA, class InB,
@@ skipping 79 matching lines @@
          class OutA, class OutB, class OutC, class OutD, class OutE>
 inline void DispatchToMethod(ObjT* obj, Method method,
                              const Tuple0& in,
                              Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
   (obj->*method)(&out->a, &out->b, &out->c, &out->d, &out->e);
 }
 
 template<class ObjT, class Method, class InA,
          class OutA, class OutB, class OutC, class OutD, class OutE>
 inline void DispatchToMethod(ObjT* obj, Method method,
-                             const InA& in,
-                             Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
-  (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in),
-                 &out->a,
-                 &out->b,
-                 &out->c,
-                 &out->d,
-                 &out->e);
-}
-
-template<class ObjT, class Method, class InA,
-         class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
                              const Tuple1<InA>& in,
                              Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
   (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
                  &out->a,
                  &out->b,
                  &out->c,
                  &out->d,
                  &out->e);
 }
 
@@ skipping 73 matching lines @@
                  base::internal::UnwrapTraits<InE>::Unwrap(in.e),
                  base::internal::UnwrapTraits<InF>::Unwrap(in.f),
                  &out->a,
                  &out->b,
                  &out->c,
                  &out->d,
                  &out->e);
 }
 
 #endif  // BASE_TUPLE_H__