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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: base/tuple.h

Issue 785153002: Add index access support to base::Tuple (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: fix 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 | « no previous file | base/tuple_unittest.cc » ('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..cf21da13d83bee9f3f69b64b09ea628f5dab8be1 100644
--- a/base/tuple.h
+++ b/base/tuple.h
@@ -3,8 +3,8 @@
// 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.
@@ -54,7 +54,7 @@ struct TupleTraits<P&> {
};
template <class P>
-struct TupleTypes { };
+struct TupleTypes;
// Tuple -----------------------------------------------------------------------
//
@@ -70,15 +70,181 @@ 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;
+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() {}
@@ -88,8 +254,7 @@ struct Tuple1 {
};
template <class A, class B>
-struct Tuple2 {
- public:
+struct Tuple2 : TupleBase<A, B> {
typedef A TypeA;
typedef B TypeB;
@@ -104,8 +269,7 @@ struct Tuple2 {
};
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;
@@ -123,8 +287,7 @@ struct Tuple3 {
};
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;
@@ -145,8 +308,7 @@ struct Tuple4 {
};
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;
@@ -155,11 +317,11 @@ struct Tuple5 {
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;
@@ -170,8 +332,7 @@ struct Tuple5 {
};
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;
@@ -181,12 +342,12 @@ struct Tuple6 {
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;
@@ -198,8 +359,7 @@ struct Tuple6 {
};
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;
@@ -210,13 +370,13 @@ struct Tuple7 {
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;
@@ -230,8 +390,7 @@ struct Tuple7 {
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;
@@ -243,14 +402,14 @@ struct Tuple8 {
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;
@@ -286,8 +445,8 @@ 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;
};
@@ -297,9 +456,9 @@ 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;
@@ -311,10 +470,10 @@ struct TupleTypes< Tuple4<A, B, C, D> > {
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,
@@ -328,11 +487,11 @@ struct TupleTypes< Tuple5<A, B, C, D, E> > {
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,
@@ -348,12 +507,12 @@ struct TupleTypes< Tuple6<A, B, C, D, E, F> > {
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,
@@ -371,13 +530,13 @@ struct TupleTypes< Tuple7<A, B, C, D, E, F, G> > {
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,
@@ -398,14 +557,14 @@ struct TupleTypes< Tuple8<A, B, C, D, E, F, G, H> > {
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,
@@ -418,108 +577,18 @@ typedef Tuple8<typename TupleTraits<A>::RefType,
// 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 <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 <typename... T>
+inline Tuple<T...> MakeTuple(const T&... p) {
+ return Tuple<T...>(p...);
}
-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 ----------------------------------------------------------------
@@ -539,11 +608,6 @@ inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& arg) {
}
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));
}
@@ -630,11 +694,6 @@ inline void DispatchToFunction(Function function, const Tuple0& arg) {
}
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));
}
@@ -719,11 +778,6 @@ inline void DispatchToMethod(ObjT* obj,
}
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*) {
@@ -790,14 +844,6 @@ inline void DispatchToMethod(ObjT* obj, Method method,
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);
@@ -877,14 +923,6 @@ inline void DispatchToMethod(ObjT* obj, Method method,
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)(
@@ -971,14 +1009,6 @@ inline void DispatchToMethod(ObjT* obj, Method method,
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),
@@ -1072,18 +1102,6 @@ inline void DispatchToMethod(ObjT* obj, Method method,
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),
@@ -1183,19 +1201,6 @@ inline void DispatchToMethod(ObjT* obj, Method method,
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),
« no previous file with comments | « no previous file | base/tuple_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698