Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(200)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: base/tuple.h

Issue 787803004: Update from https://crrev.com/307664 (Closed) Base URL: https://github.com/domokit/mojo.git@master
Patch Set: Rebase. Created 6 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « base/strings/utf_string_conversions.cc ('k') | build/OWNERS » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: base/tuple.h
diff --git a/base/tuple.h b/base/tuple.h
index 12f7f84ea50b79e4a0f92c1cb47ae0e2319a1d4a..16f51241392946b3c264687b77ef54998d86ac2c 100644
--- a/base/tuple.h
+++ b/base/tuple.h
@@ -31,6 +31,29 @@
#include "base/bind_helpers.h"
+// Index sequences
+//
+// Minimal clone of the similarly-named C++14 functionality.
+
+template <size_t...>
+struct IndexSequence {};
+
+template <size_t... Ns>
+struct MakeIndexSequenceImpl;
+
+template <size_t... Ns>
+struct MakeIndexSequenceImpl<0, Ns...> {
+ using Type = IndexSequence<Ns...>;
+};
+
+template <size_t N, size_t... Ns>
+struct MakeIndexSequenceImpl<N, Ns...> {
+ using Type = typename MakeIndexSequenceImpl<N - 1, N - 1, Ns...>::Type;
+};
+
+template <size_t N>
+using MakeIndexSequence = typename MakeIndexSequenceImpl<N>::Type;
+
// Traits ----------------------------------------------------------------------
//
// A simple traits class for tuple arguments.
@@ -53,9 +76,6 @@ struct TupleTraits<P&> {
typedef P& ParamType;
};
-template <class P>
-struct TupleTypes { };
-
// Tuple -----------------------------------------------------------------------
//
// This set of classes is useful for bundling 0 or more heterogeneous data types
@@ -70,73 +90,70 @@ struct TupleTypes { };
// 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;
-};
+template <typename... Ts>
+struct Tuple;
-template <class A>
-struct Tuple1 {
+template <>
+struct Tuple<> {};
+
+template <typename A>
+struct Tuple<A> {
public:
typedef A TypeA;
- Tuple1() {}
- explicit Tuple1(typename TupleTraits<A>::ParamType a) : a(a) {}
+ Tuple() {}
+ explicit Tuple(typename TupleTraits<A>::ParamType a) : a(a) {}
A a;
};
-template <class A, class B>
-struct Tuple2 {
+template <typename A, typename B>
+struct Tuple<A, B> {
public:
typedef A TypeA;
typedef B TypeB;
- Tuple2() {}
- Tuple2(typename TupleTraits<A>::ParamType a,
- typename TupleTraits<B>::ParamType b)
- : a(a), b(b) {
- }
+ Tuple() {}
+ Tuple(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 {
+template <typename A, typename B, typename C>
+struct Tuple<A, B, C> {
public:
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){
- }
+ Tuple() {}
+ Tuple(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 {
+template <typename A, typename B, typename C, typename D>
+struct Tuple<A, B, C, D> {
public:
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) {
- }
+ Tuple() {}
+ Tuple(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;
@@ -144,8 +161,8 @@ struct Tuple4 {
D d;
};
-template <class A, class B, class C, class D, class E>
-struct Tuple5 {
+template <typename A, typename B, typename C, typename D, typename E>
+struct Tuple<A, B, C, D, E> {
public:
typedef A TypeA;
typedef B TypeB;
@@ -153,14 +170,13 @@ struct Tuple5 {
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) {
- }
+ Tuple() {}
+ Tuple(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) {}
A a;
B b;
@@ -169,8 +185,13 @@ struct Tuple5 {
E e;
};
-template <class A, class B, class C, class D, class E, class F>
-struct Tuple6 {
+template <typename A,
+ typename B,
+ typename C,
+ typename D,
+ typename E,
+ typename F>
+struct Tuple<A, B, C, D, E, F> {
public:
typedef A TypeA;
typedef B TypeB;
@@ -179,15 +200,14 @@ struct Tuple6 {
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) {
- }
+ Tuple() {}
+ Tuple(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) {}
A a;
B b;
@@ -197,8 +217,14 @@ struct Tuple6 {
F f;
};
-template <class A, class B, class C, class D, class E, class F, class G>
-struct Tuple7 {
+template <typename A,
+ typename B,
+ typename C,
+ typename D,
+ typename E,
+ typename F,
+ typename G>
+struct Tuple<A, B, C, D, E, F, G> {
public:
typedef A TypeA;
typedef B TypeB;
@@ -208,16 +234,15 @@ struct Tuple7 {
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) {
- }
+ Tuple() {}
+ Tuple(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) {}
A a;
B b;
@@ -228,9 +253,15 @@ struct Tuple7 {
G g;
};
-template <class A, class B, class C, class D, class E, class F, class G,
- class H>
-struct Tuple8 {
+template <typename A,
+ typename B,
+ typename C,
+ typename D,
+ typename E,
+ typename F,
+ typename G,
+ typename H>
+struct Tuple<A, B, C, D, E, F, G, H> {
public:
typedef A TypeA;
typedef B TypeB;
@@ -241,17 +272,16 @@ struct Tuple8 {
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) {
- }
+ Tuple() {}
+ Tuple(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) {}
A a;
B b;
@@ -263,263 +293,162 @@ struct Tuple8 {
H h;
};
-// Tuple types ----------------------------------------------------------------
-//
-// Allows for selection of ValueTuple/RefTuple/ParamTuple without needing the
-// definitions of class types the tuple takes as parameters.
-
-template <>
-struct TupleTypes< Tuple0 > {
- typedef Tuple0 ValueTuple;
- typedef Tuple0 RefTuple;
- typedef Tuple0 ParamTuple;
+// Deprecated compat aliases
+
+using Tuple0 = Tuple<>;
+template <typename A>
+using Tuple1 = Tuple<A>;
+template <typename A, typename B>
+using Tuple2 = Tuple<A, B>;
+template <typename A, typename B, typename C>
+using Tuple3 = Tuple<A, B, C>;
+template <typename A, typename B, typename C, typename D>
+using Tuple4 = Tuple<A, B, C, D>;
+template <typename A, typename B, typename C, typename D, typename E>
+using Tuple5 = Tuple<A, B, C, D, E>;
+template <typename A,
+ typename B,
+ typename C,
+ typename D,
+ typename E,
+ typename F>
+using Tuple6 = Tuple<A, B, C, D, E, F>;
+template <typename A,
+ typename B,
+ typename C,
+ typename D,
+ typename E,
+ typename F,
+ typename G>
+using Tuple7 = Tuple<A, B, C, D, E, F, G>;
+template <typename A,
+ typename B,
+ typename C,
+ typename D,
+ typename E,
+ typename F,
+ typename G,
+ typename H>
+using Tuple8 = Tuple<A, B, C, D, E, F, G, H>;
+
+// Tuple element --------------------------------------------------------------
+
+template <size_t N, typename T>
+struct TupleElement;
+
+template <typename T, typename... Ts>
+struct TupleElement<0, Tuple<T, Ts...>> {
+ using Type = T;
};
-template <class A>
-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 <size_t N, typename T, typename... Ts>
+struct TupleElement<N, Tuple<T, Ts...>> {
+ using Type = typename TupleElement<N - 1, Tuple<Ts...>>::Type;
};
-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>::ParamType,
- typename TupleTraits<B>::ParamType> ParamTuple;
-};
+// Tuple getters --------------------------------------------------------------
-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>::ParamType,
- typename TupleTraits<B>::ParamType,
- typename TupleTraits<C>::ParamType> ParamTuple;
-};
+template <size_t, typename T>
+struct TupleGetter;
-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>::ParamType,
- typename TupleTraits<B>::ParamType,
- typename TupleTraits<C>::ParamType,
- typename TupleTraits<D>::ParamType> ParamTuple;
+template <typename... Ts>
+struct TupleGetter<0, Tuple<Ts...>> {
+ using Elem = typename TupleElement<0, Tuple<Ts...>>::Type;
+ static Elem& Get(Tuple<Ts...>& t) { return t.a; }
+ static const Elem& Get(const Tuple<Ts...>& t) { return t.a; }
};
-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>::ParamType,
- typename TupleTraits<B>::ParamType,
- typename TupleTraits<C>::ParamType,
- typename TupleTraits<D>::ParamType,
- typename TupleTraits<E>::ParamType> ParamTuple;
+template <typename... Ts>
+struct TupleGetter<1, Tuple<Ts...>> {
+ using Elem = typename TupleElement<1, Tuple<Ts...>>::Type;
+ static Elem& Get(Tuple<Ts...>& t) { return t.b; }
+ static const Elem& Get(const Tuple<Ts...>& t) { return t.b; }
};
-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>::ParamType,
- typename TupleTraits<B>::ParamType,
- typename TupleTraits<C>::ParamType,
- typename TupleTraits<D>::ParamType,
- typename TupleTraits<E>::ParamType,
- typename TupleTraits<F>::ParamType> ParamTuple;
+template <typename... Ts>
+struct TupleGetter<2, Tuple<Ts...>> {
+ using Elem = typename TupleElement<2, Tuple<Ts...>>::Type;
+ static Elem& Get(Tuple<Ts...>& t) { return t.c; }
+ static const Elem& Get(const Tuple<Ts...>& t) { return t.c; }
};
-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>::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 <typename... Ts>
+struct TupleGetter<3, Tuple<Ts...>> {
+ using Elem = typename TupleElement<3, Tuple<Ts...>>::Type;
+ static Elem& Get(Tuple<Ts...>& t) { return t.d; }
+ static const Elem& Get(const Tuple<Ts...>& t) { return t.d; }
};
-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>::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;
+template <typename... Ts>
+struct TupleGetter<4, Tuple<Ts...>> {
+ using Elem = typename TupleElement<4, Tuple<Ts...>>::Type;
+ static Elem& Get(Tuple<Ts...>& t) { return t.e; }
+ static const Elem& Get(const Tuple<Ts...>& t) { return t.e; }
};
-// Tuple creators -------------------------------------------------------------
-//
-// Helper functions for constructing tuples while inferring the template
-// argument types.
+template <typename... Ts>
+struct TupleGetter<5, Tuple<Ts...>> {
+ using Elem = typename TupleElement<5, Tuple<Ts...>>::Type;
+ static Elem& Get(Tuple<Ts...>& t) { return t.f; }
+ static const Elem& Get(const Tuple<Ts...>& t) { return t.f; }
+};
-inline Tuple0 MakeTuple() {
- return Tuple0();
-}
+template <typename... Ts>
+struct TupleGetter<6, Tuple<Ts...>> {
+ using Elem = typename TupleElement<6, Tuple<Ts...>>::Type;
+ static Elem& Get(Tuple<Ts...>& t) { return t.g; }
+ static const Elem& Get(const Tuple<Ts...>& t) { return t.g; }
+};
-template <class A>
-inline Tuple1<A> MakeTuple(const A& a) {
- return Tuple1<A>(a);
-}
+template <typename... Ts>
+struct TupleGetter<7, Tuple<Ts...>> {
+ using Elem = typename TupleElement<7, Tuple<Ts...>>::Type;
+ static Elem& Get(Tuple<Ts...>& t) { return t.h; }
+ static const Elem& Get(const Tuple<Ts...>& t) { return t.h; }
+};
-template <class A, class B>
-inline Tuple2<A, B> MakeTuple(const A& a, const B& b) {
- return Tuple2<A, B>(a, b);
+template <size_t I, typename... Ts>
+typename TupleElement<I, Tuple<Ts...>>::Type& get(Tuple<Ts...>& tuple) {
+ return TupleGetter<I, Tuple<Ts...>>::Get(tuple);
}
-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 <size_t I, typename... Ts>
+const typename TupleElement<I, Tuple<Ts...>>::Type& get(
+ const Tuple<Ts...>& tuple) {
+ return TupleGetter<I, Tuple<Ts...>>::Get(tuple);
}
-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);
-}
+// Tuple types ----------------------------------------------------------------
+//
+// Allows for selection of ValueTuple/RefTuple/ParamTuple without needing the
+// definitions of class types the tuple takes as parameters.
-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 <typename T>
+struct TupleTypes;
-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 <typename... Ts>
+struct TupleTypes<Tuple<Ts...>> {
+ using ValueTuple = Tuple<typename TupleTraits<Ts>::ValueType...>;
+ using RefTuple = Tuple<typename TupleTraits<Ts>::RefType...>;
+ using ParamTuple = Tuple<typename TupleTraits<Ts>::ParamType...>;
+};
-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);
-}
+// Tuple creators -------------------------------------------------------------
+//
+// Helper functions for constructing tuples while inferring the template
+// argument types.
-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);
+template <typename... Ts>
+inline Tuple<Ts...> MakeTuple(const Ts&... arg) {
+ return Tuple<Ts...>(arg...);
}
// The following set of helpers 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... Ts>
+inline Tuple<Ts&...> MakeRefTuple(Ts&... arg) {
+ return Tuple<Ts&...>(arg...);
}
// Dispatchers ----------------------------------------------------------------
@@ -533,759 +462,94 @@ inline Tuple8<A&, B&, C&, D&, E&, F&, G&, H&> MakeRefTuple(A& a, B& b, C& c,
// 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>
+template <typename ObjT, typename Method, typename 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 <typename ObjT, typename Method, typename... Ts, size_t... Ns>
+inline void DispatchToMethodImpl(ObjT* obj,
+ Method method,
+ const Tuple<Ts...>& arg,
+ IndexSequence<Ns...>) {
+ (obj->*method)(base::internal::UnwrapTraits<Ts>::Unwrap(get<Ns>(arg))...);
}
-template<class ObjT, class Method, class A, class B>
+template <typename ObjT, typename Method, typename... Ts>
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));
-}
-
-template<class ObjT, class Method, class A, class B, class C>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple3<A, B, C>& arg) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple4<A, B, C, D>& arg) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D, class E>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple5<A, B, C, D, E>& arg) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D, class E,
- class F>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple6<A, B, C, D, E, F>& arg) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e),
- base::internal::UnwrapTraits<F>::Unwrap(arg.f));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D, class E,
- class F, class G>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple7<A, B, C, D, E, F, G>& arg) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e),
- base::internal::UnwrapTraits<F>::Unwrap(arg.f),
- base::internal::UnwrapTraits<G>::Unwrap(arg.g));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D, class E,
- class F, class G, class H>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple8<A, B, C, D, E, F, G, H>& arg) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e),
- base::internal::UnwrapTraits<F>::Unwrap(arg.f),
- base::internal::UnwrapTraits<G>::Unwrap(arg.g),
- base::internal::UnwrapTraits<H>::Unwrap(arg.h));
+ const Tuple<Ts...>& arg) {
+ DispatchToMethodImpl(obj, method, arg, MakeIndexSequence<sizeof...(Ts)>());
}
// 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 <typename Function, typename A>
+inline void DispatchToMethod(Function function, const A& arg) {
+ (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg));
}
-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));
+template <typename Function, typename... Ts, size_t... Ns>
+inline void DispatchToFunctionImpl(Function function,
+ const Tuple<Ts...>& arg,
+ IndexSequence<Ns...>) {
+ (*function)(base::internal::UnwrapTraits<Ts>::Unwrap(get<Ns>(arg))...);
}
-template<class Function, class A, class B, class C>
-inline void DispatchToFunction(Function function, const Tuple3<A, B, C>& arg) {
- (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c));
+template <typename Function, typename... Ts>
+inline void DispatchToFunction(Function function, const Tuple<Ts...>& arg) {
+ DispatchToFunctionImpl(function, arg, MakeIndexSequence<sizeof...(Ts)>());
}
-template<class Function, class A, class B, class C, class D>
-inline void DispatchToFunction(Function function,
- const Tuple4<A, B, C, D>& arg) {
- (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d));
-}
-
-template<class Function, class A, class B, class C, class D, class E>
-inline void DispatchToFunction(Function function,
- const Tuple5<A, B, C, D, E>& arg) {
- (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e));
-}
+// Dispatchers with out parameters.
-template<class Function, class A, class B, class C, class D, class E, class F>
-inline void DispatchToFunction(Function function,
- const Tuple6<A, B, C, D, E, F>& arg) {
- (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e),
- base::internal::UnwrapTraits<F>::Unwrap(arg.f));
+template <typename ObjT,
+ typename Method,
+ typename In,
+ typename... OutTs,
+ size_t... OutNs>
+inline void DispatchToMethodImpl(ObjT* obj,
+ Method method,
+ const In& in,
+ Tuple<OutTs...>* out,
+ IndexSequence<OutNs...>) {
+ (obj->*method)(base::internal::UnwrapTraits<In>::Unwrap(in),
+ &get<OutNs>(*out)...);
}
-template<class Function, class A, class B, class C, class D, class E, class F,
- class G>
-inline void DispatchToFunction(Function function,
- const Tuple7<A, B, C, D, E, F, G>& arg) {
- (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e),
- base::internal::UnwrapTraits<F>::Unwrap(arg.f),
- base::internal::UnwrapTraits<G>::Unwrap(arg.g));
-}
-
-template<class Function, class A, class B, class C, class D, class E, class F,
- class G, class H>
-inline void DispatchToFunction(Function function,
- const Tuple8<A, B, C, D, E, F, G, H>& arg) {
- (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e),
- base::internal::UnwrapTraits<F>::Unwrap(arg.f),
- base::internal::UnwrapTraits<G>::Unwrap(arg.g),
- base::internal::UnwrapTraits<H>::Unwrap(arg.h));
-}
-
-// Dispatchers with 0 out param (as a Tuple0).
-
-template <class ObjT, class Method>
+template <typename ObjT, typename Method, typename In, typename... OutTs>
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>
+ const In& in,
+ Tuple<OutTs...>* out) {
+ DispatchToMethodImpl(obj, method, in, out,
+ MakeIndexSequence<sizeof...(OutTs)>());
+}
+
+template <typename ObjT,
+ typename Method,
+ typename... InTs,
+ typename... OutTs,
+ size_t... InNs,
+ size_t... OutNs>
+inline void DispatchToMethodImpl(ObjT* obj,
+ Method method,
+ const Tuple<InTs...>& in,
+ Tuple<OutTs...>* out,
+ IndexSequence<InNs...>,
+ IndexSequence<OutNs...>) {
+ (obj->*method)(base::internal::UnwrapTraits<InTs>::Unwrap(get<InNs>(in))...,
+ &get<OutNs>(*out)...);
+}
+
+template <typename ObjT, typename Method, typename... InTs, typename... OutTs>
inline void DispatchToMethod(ObjT* obj,
Method method,
- const Tuple2<A, B>& arg, Tuple0*) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b));
-}
-
-template<class ObjT, class Method, class A, class B, class C>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple3<A, B, C>& arg, Tuple0*) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple4<A, B, C, D>& arg, Tuple0*) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D, class E>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple5<A, B, C, D, E>& arg, Tuple0*) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D, class E,
- class F>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple6<A, B, C, D, E, F>& arg, Tuple0*) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e),
- base::internal::UnwrapTraits<F>::Unwrap(arg.f));
-}
-
-// Dispatchers with 1 out param.
-
-template<class ObjT, class Method,
- 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) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- &out->a);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC,
- class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple3<InA, InB, InC>& in,
- Tuple1<OutA>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- &out->a);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC, class InD,
- class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple4<InA, InB, InC, InD>& in,
- Tuple1<OutA>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- &out->a);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC, class InD,
- class InE, class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple5<InA, InB, InC, InD, InE>& in,
- Tuple1<OutA>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- &out->a);
-}
-
-template<class ObjT, class Method,
- class InA, class InB, class InC, class InD, class InE, class InF,
- class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple6<InA, InB, InC, InD, InE, InF>& in,
- Tuple1<OutA>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- base::internal::UnwrapTraits<InF>::Unwrap(in.f),
- &out->a);
-}
-
-// Dispatchers with 2 out params.
-
-template<class ObjT, class Method,
- 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,
- Tuple2<OutA, OutB>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- &out->a,
- &out->b);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC,
- class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple3<InA, InB, InC>& in,
- Tuple2<OutA, OutB>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- &out->a,
- &out->b);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC, class InD,
- class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple4<InA, InB, InC, InD>& in,
- Tuple2<OutA, OutB>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- &out->a,
- &out->b);
-}
-
-template<class ObjT, class Method,
- class InA, class InB, class InC, class InD, class InE,
- class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple5<InA, InB, InC, InD, InE>& in,
- Tuple2<OutA, OutB>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- &out->a,
- &out->b);
-}
-
-template<class ObjT, class Method,
- class InA, class InB, class InC, class InD, class InE, class InF,
- class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple6<InA, InB, InC, InD, InE, InF>& in,
- Tuple2<OutA, OutB>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- base::internal::UnwrapTraits<InF>::Unwrap(in.f),
- &out->a,
- &out->b);
-}
-
-// Dispatchers with 3 out params.
-
-template<class ObjT, class Method,
- 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>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple2<InA, InB>& in,
- Tuple3<OutA, OutB, OutC>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- &out->a,
- &out->b,
- &out->c);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC,
- class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple3<InA, InB, InC>& in,
- Tuple3<OutA, OutB, OutC>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- &out->a,
- &out->b,
- &out->c);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC, class InD,
- class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple4<InA, InB, InC, InD>& in,
- Tuple3<OutA, OutB, OutC>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- &out->a,
- &out->b,
- &out->c);
-}
-
-template<class ObjT, class Method,
- class InA, class InB, class InC, class InD, class InE,
- class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple5<InA, InB, InC, InD, InE>& in,
- Tuple3<OutA, OutB, OutC>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- &out->a,
- &out->b,
- &out->c);
-}
-
-template<class ObjT, class Method,
- class InA, class InB, class InC, class InD, class InE, class InF,
- class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple6<InA, InB, InC, InD, InE, InF>& in,
- Tuple3<OutA, OutB, OutC>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- base::internal::UnwrapTraits<InF>::Unwrap(in.f),
- &out->a,
- &out->b,
- &out->c);
-}
-
-// Dispatchers with 4 out params.
-
-template<class ObjT, class Method,
- 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,
- class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple2<InA, InB>& in,
- Tuple4<OutA, OutB, OutC, OutD>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- &out->a,
- &out->b,
- &out->c,
- &out->d);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC,
- class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple3<InA, InB, InC>& in,
- Tuple4<OutA, OutB, OutC, OutD>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- &out->a,
- &out->b,
- &out->c,
- &out->d);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC, class InD,
- class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple4<InA, InB, InC, InD>& in,
- Tuple4<OutA, OutB, OutC, OutD>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- &out->a,
- &out->b,
- &out->c,
- &out->d);
-}
-
-template<class ObjT, class Method,
- class InA, class InB, class InC, class InD, class InE,
- class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple5<InA, InB, InC, InD, InE>& in,
- Tuple4<OutA, OutB, OutC, OutD>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- &out->a,
- &out->b,
- &out->c,
- &out->d);
-}
-
-template<class ObjT, class Method,
- class InA, class InB, class InC, class InD, class InE, class InF,
- class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple6<InA, InB, InC, InD, InE, InF>& in,
- Tuple4<OutA, OutB, OutC, OutD>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- base::internal::UnwrapTraits<InF>::Unwrap(in.f),
- &out->a,
- &out->b,
- &out->c,
- &out->d);
-}
-
-// Dispatchers with 5 out params.
-
-template<class ObjT, class Method,
- 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);
-}
-
-template<class ObjT, class Method, class InA, class InB,
- class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple2<InA, InB>& in,
- Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- &out->a,
- &out->b,
- &out->c,
- &out->d,
- &out->e);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC,
- class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple3<InA, InB, InC>& in,
- Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- &out->a,
- &out->b,
- &out->c,
- &out->d,
- &out->e);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC, class InD,
- class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple4<InA, InB, InC, InD>& in,
- Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- &out->a,
- &out->b,
- &out->c,
- &out->d,
- &out->e);
-}
-
-template<class ObjT, class Method,
- class InA, class InB, class InC, class InD, class InE,
- class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple5<InA, InB, InC, InD, InE>& in,
- Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- &out->a,
- &out->b,
- &out->c,
- &out->d,
- &out->e);
-}
-
-template<class ObjT, class Method,
- class InA, class InB, class InC, class InD, class InE, class InF,
- class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple6<InA, InB, InC, InD, InE, InF>& in,
- Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- base::internal::UnwrapTraits<InF>::Unwrap(in.f),
- &out->a,
- &out->b,
- &out->c,
- &out->d,
- &out->e);
+ const Tuple<InTs...>& in,
+ Tuple<OutTs...>* out) {
+ DispatchToMethodImpl(obj, method, in, out,
+ MakeIndexSequence<sizeof...(InTs)>(),
+ MakeIndexSequence<sizeof...(OutTs)>());
}
#endif // BASE_TUPLE_H__
« no previous file with comments | « base/strings/utf_string_conversions.cc ('k') | build/OWNERS » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698