1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/security/sandbox/chromium/base/tuple.h Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,1291 @@
1.4 +// Copyright (c) 2011 The Chromium Authors. All rights reserved.
1.5 +// Use of this source code is governed by a BSD-style license that can be
1.6 +// found in the LICENSE file.
1.7 +
1.8 +// A Tuple is a generic templatized container, similar in concept to std::pair.
1.9 +// There are classes Tuple0 to Tuple6, cooresponding to the number of elements
1.10 +// it contains. The convenient MakeTuple() function takes 0 to 6 arguments,
1.11 +// and will construct and return the appropriate Tuple object. The functions
1.12 +// DispatchToMethod and DispatchToFunction take a function pointer or instance
1.13 +// and method pointer, and unpack a tuple into arguments to the call.
1.14 +//
1.15 +// Tuple elements are copied by value, and stored in the tuple. See the unit
1.16 +// tests for more details of how/when the values are copied.
1.17 +//
1.18 +// Example usage:
1.19 +// // These two methods of creating a Tuple are identical.
1.20 +// Tuple2<int, const char*> tuple_a(1, "wee");
1.21 +// Tuple2<int, const char*> tuple_b = MakeTuple(1, "wee");
1.22 +//
1.23 +// void SomeFunc(int a, const char* b) { }
1.24 +// DispatchToFunction(&SomeFunc, tuple_a); // SomeFunc(1, "wee")
1.25 +// DispatchToFunction(
1.26 +// &SomeFunc, MakeTuple(10, "foo")); // SomeFunc(10, "foo")
1.27 +//
1.28 +// struct { void SomeMeth(int a, int b, int c) { } } foo;
1.29 +// DispatchToMethod(&foo, &Foo::SomeMeth, MakeTuple(1, 2, 3));
1.30 +// // foo->SomeMeth(1, 2, 3);
1.31 +
1.32 +#ifndef BASE_TUPLE_H__
1.33 +#define BASE_TUPLE_H__
1.34 +
1.35 +#include "base/bind_helpers.h"
1.36 +
1.37 +// Traits ----------------------------------------------------------------------
1.38 +//
1.39 +// A simple traits class for tuple arguments.
1.40 +//
1.41 +// ValueType: the bare, nonref version of a type (same as the type for nonrefs).
1.42 +// RefType: the ref version of a type (same as the type for refs).
1.43 +// ParamType: what type to pass to functions (refs should not be constified).
1.44 +
1.45 +template <class P>
1.46 +struct TupleTraits {
1.47 + typedef P ValueType;
1.48 + typedef P& RefType;
1.49 + typedef const P& ParamType;
1.50 +};
1.51 +
1.52 +template <class P>
1.53 +struct TupleTraits<P&> {
1.54 + typedef P ValueType;
1.55 + typedef P& RefType;
1.56 + typedef P& ParamType;
1.57 +};
1.58 +
1.59 +template <class P>
1.60 +struct TupleTypes { };
1.61 +
1.62 +// Tuple -----------------------------------------------------------------------
1.63 +//
1.64 +// This set of classes is useful for bundling 0 or more heterogeneous data types
1.65 +// into a single variable. The advantage of this is that it greatly simplifies
1.66 +// function objects that need to take an arbitrary number of parameters; see
1.67 +// RunnableMethod and IPC::MessageWithTuple.
1.68 +//
1.69 +// Tuple0 is supplied to act as a 'void' type. It can be used, for example,
1.70 +// when dispatching to a function that accepts no arguments (see the
1.71 +// Dispatchers below).
1.72 +// Tuple1<A> is rarely useful. One such use is when A is non-const ref that you
1.73 +// want filled by the dispatchee, and the tuple is merely a container for that
1.74 +// output (a "tier"). See MakeRefTuple and its usages.
1.75 +
1.76 +struct Tuple0 {
1.77 + typedef Tuple0 ValueTuple;
1.78 + typedef Tuple0 RefTuple;
1.79 + typedef Tuple0 ParamTuple;
1.80 +};
1.81 +
1.82 +template <class A>
1.83 +struct Tuple1 {
1.84 + public:
1.85 + typedef A TypeA;
1.86 +
1.87 + Tuple1() {}
1.88 + explicit Tuple1(typename TupleTraits<A>::ParamType a) : a(a) {}
1.89 +
1.90 + A a;
1.91 +};
1.92 +
1.93 +template <class A, class B>
1.94 +struct Tuple2 {
1.95 + public:
1.96 + typedef A TypeA;
1.97 + typedef B TypeB;
1.98 +
1.99 + Tuple2() {}
1.100 + Tuple2(typename TupleTraits<A>::ParamType a,
1.101 + typename TupleTraits<B>::ParamType b)
1.102 + : a(a), b(b) {
1.103 + }
1.104 +
1.105 + A a;
1.106 + B b;
1.107 +};
1.108 +
1.109 +template <class A, class B, class C>
1.110 +struct Tuple3 {
1.111 + public:
1.112 + typedef A TypeA;
1.113 + typedef B TypeB;
1.114 + typedef C TypeC;
1.115 +
1.116 + Tuple3() {}
1.117 + Tuple3(typename TupleTraits<A>::ParamType a,
1.118 + typename TupleTraits<B>::ParamType b,
1.119 + typename TupleTraits<C>::ParamType c)
1.120 + : a(a), b(b), c(c){
1.121 + }
1.122 +
1.123 + A a;
1.124 + B b;
1.125 + C c;
1.126 +};
1.127 +
1.128 +template <class A, class B, class C, class D>
1.129 +struct Tuple4 {
1.130 + public:
1.131 + typedef A TypeA;
1.132 + typedef B TypeB;
1.133 + typedef C TypeC;
1.134 + typedef D TypeD;
1.135 +
1.136 + Tuple4() {}
1.137 + Tuple4(typename TupleTraits<A>::ParamType a,
1.138 + typename TupleTraits<B>::ParamType b,
1.139 + typename TupleTraits<C>::ParamType c,
1.140 + typename TupleTraits<D>::ParamType d)
1.141 + : a(a), b(b), c(c), d(d) {
1.142 + }
1.143 +
1.144 + A a;
1.145 + B b;
1.146 + C c;
1.147 + D d;
1.148 +};
1.149 +
1.150 +template <class A, class B, class C, class D, class E>
1.151 +struct Tuple5 {
1.152 + public:
1.153 + typedef A TypeA;
1.154 + typedef B TypeB;
1.155 + typedef C TypeC;
1.156 + typedef D TypeD;
1.157 + typedef E TypeE;
1.158 +
1.159 + Tuple5() {}
1.160 + Tuple5(typename TupleTraits<A>::ParamType a,
1.161 + typename TupleTraits<B>::ParamType b,
1.162 + typename TupleTraits<C>::ParamType c,
1.163 + typename TupleTraits<D>::ParamType d,
1.164 + typename TupleTraits<E>::ParamType e)
1.165 + : a(a), b(b), c(c), d(d), e(e) {
1.166 + }
1.167 +
1.168 + A a;
1.169 + B b;
1.170 + C c;
1.171 + D d;
1.172 + E e;
1.173 +};
1.174 +
1.175 +template <class A, class B, class C, class D, class E, class F>
1.176 +struct Tuple6 {
1.177 + public:
1.178 + typedef A TypeA;
1.179 + typedef B TypeB;
1.180 + typedef C TypeC;
1.181 + typedef D TypeD;
1.182 + typedef E TypeE;
1.183 + typedef F TypeF;
1.184 +
1.185 + Tuple6() {}
1.186 + Tuple6(typename TupleTraits<A>::ParamType a,
1.187 + typename TupleTraits<B>::ParamType b,
1.188 + typename TupleTraits<C>::ParamType c,
1.189 + typename TupleTraits<D>::ParamType d,
1.190 + typename TupleTraits<E>::ParamType e,
1.191 + typename TupleTraits<F>::ParamType f)
1.192 + : a(a), b(b), c(c), d(d), e(e), f(f) {
1.193 + }
1.194 +
1.195 + A a;
1.196 + B b;
1.197 + C c;
1.198 + D d;
1.199 + E e;
1.200 + F f;
1.201 +};
1.202 +
1.203 +template <class A, class B, class C, class D, class E, class F, class G>
1.204 +struct Tuple7 {
1.205 + public:
1.206 + typedef A TypeA;
1.207 + typedef B TypeB;
1.208 + typedef C TypeC;
1.209 + typedef D TypeD;
1.210 + typedef E TypeE;
1.211 + typedef F TypeF;
1.212 + typedef G TypeG;
1.213 +
1.214 + Tuple7() {}
1.215 + Tuple7(typename TupleTraits<A>::ParamType a,
1.216 + typename TupleTraits<B>::ParamType b,
1.217 + typename TupleTraits<C>::ParamType c,
1.218 + typename TupleTraits<D>::ParamType d,
1.219 + typename TupleTraits<E>::ParamType e,
1.220 + typename TupleTraits<F>::ParamType f,
1.221 + typename TupleTraits<G>::ParamType g)
1.222 + : a(a), b(b), c(c), d(d), e(e), f(f), g(g) {
1.223 + }
1.224 +
1.225 + A a;
1.226 + B b;
1.227 + C c;
1.228 + D d;
1.229 + E e;
1.230 + F f;
1.231 + G g;
1.232 +};
1.233 +
1.234 +template <class A, class B, class C, class D, class E, class F, class G,
1.235 + class H>
1.236 +struct Tuple8 {
1.237 + public:
1.238 + typedef A TypeA;
1.239 + typedef B TypeB;
1.240 + typedef C TypeC;
1.241 + typedef D TypeD;
1.242 + typedef E TypeE;
1.243 + typedef F TypeF;
1.244 + typedef G TypeG;
1.245 + typedef H TypeH;
1.246 +
1.247 + Tuple8() {}
1.248 + Tuple8(typename TupleTraits<A>::ParamType a,
1.249 + typename TupleTraits<B>::ParamType b,
1.250 + typename TupleTraits<C>::ParamType c,
1.251 + typename TupleTraits<D>::ParamType d,
1.252 + typename TupleTraits<E>::ParamType e,
1.253 + typename TupleTraits<F>::ParamType f,
1.254 + typename TupleTraits<G>::ParamType g,
1.255 + typename TupleTraits<H>::ParamType h)
1.256 + : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h) {
1.257 + }
1.258 +
1.259 + A a;
1.260 + B b;
1.261 + C c;
1.262 + D d;
1.263 + E e;
1.264 + F f;
1.265 + G g;
1.266 + H h;
1.267 +};
1.268 +
1.269 +// Tuple types ----------------------------------------------------------------
1.270 +//
1.271 +// Allows for selection of ValueTuple/RefTuple/ParamTuple without needing the
1.272 +// definitions of class types the tuple takes as parameters.
1.273 +
1.274 +template <>
1.275 +struct TupleTypes< Tuple0 > {
1.276 + typedef Tuple0 ValueTuple;
1.277 + typedef Tuple0 RefTuple;
1.278 + typedef Tuple0 ParamTuple;
1.279 +};
1.280 +
1.281 +template <class A>
1.282 +struct TupleTypes< Tuple1<A> > {
1.283 + typedef Tuple1<typename TupleTraits<A>::ValueType> ValueTuple;
1.284 + typedef Tuple1<typename TupleTraits<A>::RefType> RefTuple;
1.285 + typedef Tuple1<typename TupleTraits<A>::ParamType> ParamTuple;
1.286 +};
1.287 +
1.288 +template <class A, class B>
1.289 +struct TupleTypes< Tuple2<A, B> > {
1.290 + typedef Tuple2<typename TupleTraits<A>::ValueType,
1.291 + typename TupleTraits<B>::ValueType> ValueTuple;
1.292 +typedef Tuple2<typename TupleTraits<A>::RefType,
1.293 + typename TupleTraits<B>::RefType> RefTuple;
1.294 + typedef Tuple2<typename TupleTraits<A>::ParamType,
1.295 + typename TupleTraits<B>::ParamType> ParamTuple;
1.296 +};
1.297 +
1.298 +template <class A, class B, class C>
1.299 +struct TupleTypes< Tuple3<A, B, C> > {
1.300 + typedef Tuple3<typename TupleTraits<A>::ValueType,
1.301 + typename TupleTraits<B>::ValueType,
1.302 + typename TupleTraits<C>::ValueType> ValueTuple;
1.303 +typedef Tuple3<typename TupleTraits<A>::RefType,
1.304 + typename TupleTraits<B>::RefType,
1.305 + typename TupleTraits<C>::RefType> RefTuple;
1.306 + typedef Tuple3<typename TupleTraits<A>::ParamType,
1.307 + typename TupleTraits<B>::ParamType,
1.308 + typename TupleTraits<C>::ParamType> ParamTuple;
1.309 +};
1.310 +
1.311 +template <class A, class B, class C, class D>
1.312 +struct TupleTypes< Tuple4<A, B, C, D> > {
1.313 + typedef Tuple4<typename TupleTraits<A>::ValueType,
1.314 + typename TupleTraits<B>::ValueType,
1.315 + typename TupleTraits<C>::ValueType,
1.316 + typename TupleTraits<D>::ValueType> ValueTuple;
1.317 +typedef Tuple4<typename TupleTraits<A>::RefType,
1.318 + typename TupleTraits<B>::RefType,
1.319 + typename TupleTraits<C>::RefType,
1.320 + typename TupleTraits<D>::RefType> RefTuple;
1.321 + typedef Tuple4<typename TupleTraits<A>::ParamType,
1.322 + typename TupleTraits<B>::ParamType,
1.323 + typename TupleTraits<C>::ParamType,
1.324 + typename TupleTraits<D>::ParamType> ParamTuple;
1.325 +};
1.326 +
1.327 +template <class A, class B, class C, class D, class E>
1.328 +struct TupleTypes< Tuple5<A, B, C, D, E> > {
1.329 + typedef Tuple5<typename TupleTraits<A>::ValueType,
1.330 + typename TupleTraits<B>::ValueType,
1.331 + typename TupleTraits<C>::ValueType,
1.332 + typename TupleTraits<D>::ValueType,
1.333 + typename TupleTraits<E>::ValueType> ValueTuple;
1.334 +typedef Tuple5<typename TupleTraits<A>::RefType,
1.335 + typename TupleTraits<B>::RefType,
1.336 + typename TupleTraits<C>::RefType,
1.337 + typename TupleTraits<D>::RefType,
1.338 + typename TupleTraits<E>::RefType> RefTuple;
1.339 + typedef Tuple5<typename TupleTraits<A>::ParamType,
1.340 + typename TupleTraits<B>::ParamType,
1.341 + typename TupleTraits<C>::ParamType,
1.342 + typename TupleTraits<D>::ParamType,
1.343 + typename TupleTraits<E>::ParamType> ParamTuple;
1.344 +};
1.345 +
1.346 +template <class A, class B, class C, class D, class E, class F>
1.347 +struct TupleTypes< Tuple6<A, B, C, D, E, F> > {
1.348 + typedef Tuple6<typename TupleTraits<A>::ValueType,
1.349 + typename TupleTraits<B>::ValueType,
1.350 + typename TupleTraits<C>::ValueType,
1.351 + typename TupleTraits<D>::ValueType,
1.352 + typename TupleTraits<E>::ValueType,
1.353 + typename TupleTraits<F>::ValueType> ValueTuple;
1.354 +typedef Tuple6<typename TupleTraits<A>::RefType,
1.355 + typename TupleTraits<B>::RefType,
1.356 + typename TupleTraits<C>::RefType,
1.357 + typename TupleTraits<D>::RefType,
1.358 + typename TupleTraits<E>::RefType,
1.359 + typename TupleTraits<F>::RefType> RefTuple;
1.360 + typedef Tuple6<typename TupleTraits<A>::ParamType,
1.361 + typename TupleTraits<B>::ParamType,
1.362 + typename TupleTraits<C>::ParamType,
1.363 + typename TupleTraits<D>::ParamType,
1.364 + typename TupleTraits<E>::ParamType,
1.365 + typename TupleTraits<F>::ParamType> ParamTuple;
1.366 +};
1.367 +
1.368 +template <class A, class B, class C, class D, class E, class F, class G>
1.369 +struct TupleTypes< Tuple7<A, B, C, D, E, F, G> > {
1.370 + typedef Tuple7<typename TupleTraits<A>::ValueType,
1.371 + typename TupleTraits<B>::ValueType,
1.372 + typename TupleTraits<C>::ValueType,
1.373 + typename TupleTraits<D>::ValueType,
1.374 + typename TupleTraits<E>::ValueType,
1.375 + typename TupleTraits<F>::ValueType,
1.376 + typename TupleTraits<G>::ValueType> ValueTuple;
1.377 +typedef Tuple7<typename TupleTraits<A>::RefType,
1.378 + typename TupleTraits<B>::RefType,
1.379 + typename TupleTraits<C>::RefType,
1.380 + typename TupleTraits<D>::RefType,
1.381 + typename TupleTraits<E>::RefType,
1.382 + typename TupleTraits<F>::RefType,
1.383 + typename TupleTraits<G>::RefType> RefTuple;
1.384 + typedef Tuple7<typename TupleTraits<A>::ParamType,
1.385 + typename TupleTraits<B>::ParamType,
1.386 + typename TupleTraits<C>::ParamType,
1.387 + typename TupleTraits<D>::ParamType,
1.388 + typename TupleTraits<E>::ParamType,
1.389 + typename TupleTraits<F>::ParamType,
1.390 + typename TupleTraits<G>::ParamType> ParamTuple;
1.391 +};
1.392 +
1.393 +template <class A, class B, class C, class D, class E, class F, class G,
1.394 + class H>
1.395 +struct TupleTypes< Tuple8<A, B, C, D, E, F, G, H> > {
1.396 + typedef Tuple8<typename TupleTraits<A>::ValueType,
1.397 + typename TupleTraits<B>::ValueType,
1.398 + typename TupleTraits<C>::ValueType,
1.399 + typename TupleTraits<D>::ValueType,
1.400 + typename TupleTraits<E>::ValueType,
1.401 + typename TupleTraits<F>::ValueType,
1.402 + typename TupleTraits<G>::ValueType,
1.403 + typename TupleTraits<H>::ValueType> ValueTuple;
1.404 +typedef Tuple8<typename TupleTraits<A>::RefType,
1.405 + typename TupleTraits<B>::RefType,
1.406 + typename TupleTraits<C>::RefType,
1.407 + typename TupleTraits<D>::RefType,
1.408 + typename TupleTraits<E>::RefType,
1.409 + typename TupleTraits<F>::RefType,
1.410 + typename TupleTraits<G>::RefType,
1.411 + typename TupleTraits<H>::RefType> RefTuple;
1.412 + typedef Tuple8<typename TupleTraits<A>::ParamType,
1.413 + typename TupleTraits<B>::ParamType,
1.414 + typename TupleTraits<C>::ParamType,
1.415 + typename TupleTraits<D>::ParamType,
1.416 + typename TupleTraits<E>::ParamType,
1.417 + typename TupleTraits<F>::ParamType,
1.418 + typename TupleTraits<G>::ParamType,
1.419 + typename TupleTraits<H>::ParamType> ParamTuple;
1.420 +};
1.421 +
1.422 +// Tuple creators -------------------------------------------------------------
1.423 +//
1.424 +// Helper functions for constructing tuples while inferring the template
1.425 +// argument types.
1.426 +
1.427 +inline Tuple0 MakeTuple() {
1.428 + return Tuple0();
1.429 +}
1.430 +
1.431 +template <class A>
1.432 +inline Tuple1<A> MakeTuple(const A& a) {
1.433 + return Tuple1<A>(a);
1.434 +}
1.435 +
1.436 +template <class A, class B>
1.437 +inline Tuple2<A, B> MakeTuple(const A& a, const B& b) {
1.438 + return Tuple2<A, B>(a, b);
1.439 +}
1.440 +
1.441 +template <class A, class B, class C>
1.442 +inline Tuple3<A, B, C> MakeTuple(const A& a, const B& b, const C& c) {
1.443 + return Tuple3<A, B, C>(a, b, c);
1.444 +}
1.445 +
1.446 +template <class A, class B, class C, class D>
1.447 +inline Tuple4<A, B, C, D> MakeTuple(const A& a, const B& b, const C& c,
1.448 + const D& d) {
1.449 + return Tuple4<A, B, C, D>(a, b, c, d);
1.450 +}
1.451 +
1.452 +template <class A, class B, class C, class D, class E>
1.453 +inline Tuple5<A, B, C, D, E> MakeTuple(const A& a, const B& b, const C& c,
1.454 + const D& d, const E& e) {
1.455 + return Tuple5<A, B, C, D, E>(a, b, c, d, e);
1.456 +}
1.457 +
1.458 +template <class A, class B, class C, class D, class E, class F>
1.459 +inline Tuple6<A, B, C, D, E, F> MakeTuple(const A& a, const B& b, const C& c,
1.460 + const D& d, const E& e, const F& f) {
1.461 + return Tuple6<A, B, C, D, E, F>(a, b, c, d, e, f);
1.462 +}
1.463 +
1.464 +template <class A, class B, class C, class D, class E, class F, class G>
1.465 +inline Tuple7<A, B, C, D, E, F, G> MakeTuple(const A& a, const B& b, const C& c,
1.466 + const D& d, const E& e, const F& f,
1.467 + const G& g) {
1.468 + return Tuple7<A, B, C, D, E, F, G>(a, b, c, d, e, f, g);
1.469 +}
1.470 +
1.471 +template <class A, class B, class C, class D, class E, class F, class G,
1.472 + class H>
1.473 +inline Tuple8<A, B, C, D, E, F, G, H> MakeTuple(const A& a, const B& b,
1.474 + const C& c, const D& d,
1.475 + const E& e, const F& f,
1.476 + const G& g, const H& h) {
1.477 + return Tuple8<A, B, C, D, E, F, G, H>(a, b, c, d, e, f, g, h);
1.478 +}
1.479 +
1.480 +// The following set of helpers make what Boost refers to as "Tiers" - a tuple
1.481 +// of references.
1.482 +
1.483 +template <class A>
1.484 +inline Tuple1<A&> MakeRefTuple(A& a) {
1.485 + return Tuple1<A&>(a);
1.486 +}
1.487 +
1.488 +template <class A, class B>
1.489 +inline Tuple2<A&, B&> MakeRefTuple(A& a, B& b) {
1.490 + return Tuple2<A&, B&>(a, b);
1.491 +}
1.492 +
1.493 +template <class A, class B, class C>
1.494 +inline Tuple3<A&, B&, C&> MakeRefTuple(A& a, B& b, C& c) {
1.495 + return Tuple3<A&, B&, C&>(a, b, c);
1.496 +}
1.497 +
1.498 +template <class A, class B, class C, class D>
1.499 +inline Tuple4<A&, B&, C&, D&> MakeRefTuple(A& a, B& b, C& c, D& d) {
1.500 + return Tuple4<A&, B&, C&, D&>(a, b, c, d);
1.501 +}
1.502 +
1.503 +template <class A, class B, class C, class D, class E>
1.504 +inline Tuple5<A&, B&, C&, D&, E&> MakeRefTuple(A& a, B& b, C& c, D& d, E& e) {
1.505 + return Tuple5<A&, B&, C&, D&, E&>(a, b, c, d, e);
1.506 +}
1.507 +
1.508 +template <class A, class B, class C, class D, class E, class F>
1.509 +inline Tuple6<A&, B&, C&, D&, E&, F&> MakeRefTuple(A& a, B& b, C& c, D& d, E& e,
1.510 + F& f) {
1.511 + return Tuple6<A&, B&, C&, D&, E&, F&>(a, b, c, d, e, f);
1.512 +}
1.513 +
1.514 +template <class A, class B, class C, class D, class E, class F, class G>
1.515 +inline Tuple7<A&, B&, C&, D&, E&, F&, G&> MakeRefTuple(A& a, B& b, C& c, D& d,
1.516 + E& e, F& f, G& g) {
1.517 + return Tuple7<A&, B&, C&, D&, E&, F&, G&>(a, b, c, d, e, f, g);
1.518 +}
1.519 +
1.520 +template <class A, class B, class C, class D, class E, class F, class G,
1.521 + class H>
1.522 +inline Tuple8<A&, B&, C&, D&, E&, F&, G&, H&> MakeRefTuple(A& a, B& b, C& c,
1.523 + D& d, E& e, F& f,
1.524 + G& g, H& h) {
1.525 + return Tuple8<A&, B&, C&, D&, E&, F&, G&, H&>(a, b, c, d, e, f, g, h);
1.526 +}
1.527 +
1.528 +// Dispatchers ----------------------------------------------------------------
1.529 +//
1.530 +// Helper functions that call the given method on an object, with the unpacked
1.531 +// tuple arguments. Notice that they all have the same number of arguments,
1.532 +// so you need only write:
1.533 +// DispatchToMethod(object, &Object::method, args);
1.534 +// This is very useful for templated dispatchers, since they don't need to know
1.535 +// what type |args| is.
1.536 +
1.537 +// Non-Static Dispatchers with no out params.
1.538 +
1.539 +template <class ObjT, class Method>
1.540 +inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& arg) {
1.541 + (obj->*method)();
1.542 +}
1.543 +
1.544 +template <class ObjT, class Method, class A>
1.545 +inline void DispatchToMethod(ObjT* obj, Method method, const A& arg) {
1.546 + (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg));
1.547 +}
1.548 +
1.549 +template <class ObjT, class Method, class A>
1.550 +inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1<A>& arg) {
1.551 + (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a));
1.552 +}
1.553 +
1.554 +template<class ObjT, class Method, class A, class B>
1.555 +inline void DispatchToMethod(ObjT* obj,
1.556 + Method method,
1.557 + const Tuple2<A, B>& arg) {
1.558 + (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.559 + base::internal::UnwrapTraits<B>::Unwrap(arg.b));
1.560 +}
1.561 +
1.562 +template<class ObjT, class Method, class A, class B, class C>
1.563 +inline void DispatchToMethod(ObjT* obj, Method method,
1.564 + const Tuple3<A, B, C>& arg) {
1.565 + (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.566 + base::internal::UnwrapTraits<B>::Unwrap(arg.b),
1.567 + base::internal::UnwrapTraits<C>::Unwrap(arg.c));
1.568 +}
1.569 +
1.570 +template<class ObjT, class Method, class A, class B, class C, class D>
1.571 +inline void DispatchToMethod(ObjT* obj, Method method,
1.572 + const Tuple4<A, B, C, D>& arg) {
1.573 + (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.574 + base::internal::UnwrapTraits<B>::Unwrap(arg.b),
1.575 + base::internal::UnwrapTraits<C>::Unwrap(arg.c),
1.576 + base::internal::UnwrapTraits<D>::Unwrap(arg.d));
1.577 +}
1.578 +
1.579 +template<class ObjT, class Method, class A, class B, class C, class D, class E>
1.580 +inline void DispatchToMethod(ObjT* obj, Method method,
1.581 + const Tuple5<A, B, C, D, E>& arg) {
1.582 + (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.583 + base::internal::UnwrapTraits<B>::Unwrap(arg.b),
1.584 + base::internal::UnwrapTraits<C>::Unwrap(arg.c),
1.585 + base::internal::UnwrapTraits<D>::Unwrap(arg.d),
1.586 + base::internal::UnwrapTraits<E>::Unwrap(arg.e));
1.587 +}
1.588 +
1.589 +template<class ObjT, class Method, class A, class B, class C, class D, class E,
1.590 + class F>
1.591 +inline void DispatchToMethod(ObjT* obj, Method method,
1.592 + const Tuple6<A, B, C, D, E, F>& arg) {
1.593 + (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.594 + base::internal::UnwrapTraits<B>::Unwrap(arg.b),
1.595 + base::internal::UnwrapTraits<C>::Unwrap(arg.c),
1.596 + base::internal::UnwrapTraits<D>::Unwrap(arg.d),
1.597 + base::internal::UnwrapTraits<E>::Unwrap(arg.e),
1.598 + base::internal::UnwrapTraits<F>::Unwrap(arg.f));
1.599 +}
1.600 +
1.601 +template<class ObjT, class Method, class A, class B, class C, class D, class E,
1.602 + class F, class G>
1.603 +inline void DispatchToMethod(ObjT* obj, Method method,
1.604 + const Tuple7<A, B, C, D, E, F, G>& arg) {
1.605 + (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.606 + base::internal::UnwrapTraits<B>::Unwrap(arg.b),
1.607 + base::internal::UnwrapTraits<C>::Unwrap(arg.c),
1.608 + base::internal::UnwrapTraits<D>::Unwrap(arg.d),
1.609 + base::internal::UnwrapTraits<E>::Unwrap(arg.e),
1.610 + base::internal::UnwrapTraits<F>::Unwrap(arg.f),
1.611 + base::internal::UnwrapTraits<G>::Unwrap(arg.g));
1.612 +}
1.613 +
1.614 +template<class ObjT, class Method, class A, class B, class C, class D, class E,
1.615 + class F, class G, class H>
1.616 +inline void DispatchToMethod(ObjT* obj, Method method,
1.617 + const Tuple8<A, B, C, D, E, F, G, H>& arg) {
1.618 + (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.619 + base::internal::UnwrapTraits<B>::Unwrap(arg.b),
1.620 + base::internal::UnwrapTraits<C>::Unwrap(arg.c),
1.621 + base::internal::UnwrapTraits<D>::Unwrap(arg.d),
1.622 + base::internal::UnwrapTraits<E>::Unwrap(arg.e),
1.623 + base::internal::UnwrapTraits<F>::Unwrap(arg.f),
1.624 + base::internal::UnwrapTraits<G>::Unwrap(arg.g),
1.625 + base::internal::UnwrapTraits<H>::Unwrap(arg.h));
1.626 +}
1.627 +
1.628 +// Static Dispatchers with no out params.
1.629 +
1.630 +template <class Function>
1.631 +inline void DispatchToFunction(Function function, const Tuple0& arg) {
1.632 + (*function)();
1.633 +}
1.634 +
1.635 +template <class Function, class A>
1.636 +inline void DispatchToFunction(Function function, const A& arg) {
1.637 + (*function)(arg);
1.638 +}
1.639 +
1.640 +template <class Function, class A>
1.641 +inline void DispatchToFunction(Function function, const Tuple1<A>& arg) {
1.642 + (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a));
1.643 +}
1.644 +
1.645 +template<class Function, class A, class B>
1.646 +inline void DispatchToFunction(Function function, const Tuple2<A, B>& arg) {
1.647 + (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.648 + base::internal::UnwrapTraits<B>::Unwrap(arg.b));
1.649 +}
1.650 +
1.651 +template<class Function, class A, class B, class C>
1.652 +inline void DispatchToFunction(Function function, const Tuple3<A, B, C>& arg) {
1.653 + (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.654 + base::internal::UnwrapTraits<B>::Unwrap(arg.b),
1.655 + base::internal::UnwrapTraits<C>::Unwrap(arg.c));
1.656 +}
1.657 +
1.658 +template<class Function, class A, class B, class C, class D>
1.659 +inline void DispatchToFunction(Function function,
1.660 + const Tuple4<A, B, C, D>& arg) {
1.661 + (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.662 + base::internal::UnwrapTraits<B>::Unwrap(arg.b),
1.663 + base::internal::UnwrapTraits<C>::Unwrap(arg.c),
1.664 + base::internal::UnwrapTraits<D>::Unwrap(arg.d));
1.665 +}
1.666 +
1.667 +template<class Function, class A, class B, class C, class D, class E>
1.668 +inline void DispatchToFunction(Function function,
1.669 + const Tuple5<A, B, C, D, E>& arg) {
1.670 + (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.671 + base::internal::UnwrapTraits<B>::Unwrap(arg.b),
1.672 + base::internal::UnwrapTraits<C>::Unwrap(arg.c),
1.673 + base::internal::UnwrapTraits<D>::Unwrap(arg.d),
1.674 + base::internal::UnwrapTraits<E>::Unwrap(arg.e));
1.675 +}
1.676 +
1.677 +template<class Function, class A, class B, class C, class D, class E, class F>
1.678 +inline void DispatchToFunction(Function function,
1.679 + const Tuple6<A, B, C, D, E, F>& arg) {
1.680 + (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.681 + base::internal::UnwrapTraits<B>::Unwrap(arg.b),
1.682 + base::internal::UnwrapTraits<C>::Unwrap(arg.c),
1.683 + base::internal::UnwrapTraits<D>::Unwrap(arg.d),
1.684 + base::internal::UnwrapTraits<E>::Unwrap(arg.e),
1.685 + base::internal::UnwrapTraits<F>::Unwrap(arg.f));
1.686 +}
1.687 +
1.688 +template<class Function, class A, class B, class C, class D, class E, class F,
1.689 + class G>
1.690 +inline void DispatchToFunction(Function function,
1.691 + const Tuple7<A, B, C, D, E, F, G>& arg) {
1.692 + (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.693 + base::internal::UnwrapTraits<B>::Unwrap(arg.b),
1.694 + base::internal::UnwrapTraits<C>::Unwrap(arg.c),
1.695 + base::internal::UnwrapTraits<D>::Unwrap(arg.d),
1.696 + base::internal::UnwrapTraits<E>::Unwrap(arg.e),
1.697 + base::internal::UnwrapTraits<F>::Unwrap(arg.f),
1.698 + base::internal::UnwrapTraits<G>::Unwrap(arg.g));
1.699 +}
1.700 +
1.701 +template<class Function, class A, class B, class C, class D, class E, class F,
1.702 + class G, class H>
1.703 +inline void DispatchToFunction(Function function,
1.704 + const Tuple8<A, B, C, D, E, F, G, H>& arg) {
1.705 + (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.706 + base::internal::UnwrapTraits<B>::Unwrap(arg.b),
1.707 + base::internal::UnwrapTraits<C>::Unwrap(arg.c),
1.708 + base::internal::UnwrapTraits<D>::Unwrap(arg.d),
1.709 + base::internal::UnwrapTraits<E>::Unwrap(arg.e),
1.710 + base::internal::UnwrapTraits<F>::Unwrap(arg.f),
1.711 + base::internal::UnwrapTraits<G>::Unwrap(arg.g),
1.712 + base::internal::UnwrapTraits<H>::Unwrap(arg.h));
1.713 +}
1.714 +
1.715 +// Dispatchers with 0 out param (as a Tuple0).
1.716 +
1.717 +template <class ObjT, class Method>
1.718 +inline void DispatchToMethod(ObjT* obj,
1.719 + Method method,
1.720 + const Tuple0& arg, Tuple0*) {
1.721 + (obj->*method)();
1.722 +}
1.723 +
1.724 +template <class ObjT, class Method, class A>
1.725 +inline void DispatchToMethod(ObjT* obj, Method method, const A& arg, Tuple0*) {
1.726 + (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg));
1.727 +}
1.728 +
1.729 +template <class ObjT, class Method, class A>
1.730 +inline void DispatchToMethod(ObjT* obj,
1.731 + Method method,
1.732 + const Tuple1<A>& arg, Tuple0*) {
1.733 + (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a));
1.734 +}
1.735 +
1.736 +template<class ObjT, class Method, class A, class B>
1.737 +inline void DispatchToMethod(ObjT* obj,
1.738 + Method method,
1.739 + const Tuple2<A, B>& arg, Tuple0*) {
1.740 + (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.741 + base::internal::UnwrapTraits<B>::Unwrap(arg.b));
1.742 +}
1.743 +
1.744 +template<class ObjT, class Method, class A, class B, class C>
1.745 +inline void DispatchToMethod(ObjT* obj, Method method,
1.746 + const Tuple3<A, B, C>& arg, Tuple0*) {
1.747 + (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.748 + base::internal::UnwrapTraits<B>::Unwrap(arg.b),
1.749 + base::internal::UnwrapTraits<C>::Unwrap(arg.c));
1.750 +}
1.751 +
1.752 +template<class ObjT, class Method, class A, class B, class C, class D>
1.753 +inline void DispatchToMethod(ObjT* obj, Method method,
1.754 + const Tuple4<A, B, C, D>& arg, Tuple0*) {
1.755 + (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.756 + base::internal::UnwrapTraits<B>::Unwrap(arg.b),
1.757 + base::internal::UnwrapTraits<C>::Unwrap(arg.c),
1.758 + base::internal::UnwrapTraits<D>::Unwrap(arg.d));
1.759 +}
1.760 +
1.761 +template<class ObjT, class Method, class A, class B, class C, class D, class E>
1.762 +inline void DispatchToMethod(ObjT* obj, Method method,
1.763 + const Tuple5<A, B, C, D, E>& arg, Tuple0*) {
1.764 + (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.765 + base::internal::UnwrapTraits<B>::Unwrap(arg.b),
1.766 + base::internal::UnwrapTraits<C>::Unwrap(arg.c),
1.767 + base::internal::UnwrapTraits<D>::Unwrap(arg.d),
1.768 + base::internal::UnwrapTraits<E>::Unwrap(arg.e));
1.769 +}
1.770 +
1.771 +template<class ObjT, class Method, class A, class B, class C, class D, class E,
1.772 + class F>
1.773 +inline void DispatchToMethod(ObjT* obj, Method method,
1.774 + const Tuple6<A, B, C, D, E, F>& arg, Tuple0*) {
1.775 + (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
1.776 + base::internal::UnwrapTraits<B>::Unwrap(arg.b),
1.777 + base::internal::UnwrapTraits<C>::Unwrap(arg.c),
1.778 + base::internal::UnwrapTraits<D>::Unwrap(arg.d),
1.779 + base::internal::UnwrapTraits<E>::Unwrap(arg.e),
1.780 + base::internal::UnwrapTraits<F>::Unwrap(arg.f));
1.781 +}
1.782 +
1.783 +// Dispatchers with 1 out param.
1.784 +
1.785 +template<class ObjT, class Method,
1.786 + class OutA>
1.787 +inline void DispatchToMethod(ObjT* obj, Method method,
1.788 + const Tuple0& in,
1.789 + Tuple1<OutA>* out) {
1.790 + (obj->*method)(&out->a);
1.791 +}
1.792 +
1.793 +template<class ObjT, class Method, class InA,
1.794 + class OutA>
1.795 +inline void DispatchToMethod(ObjT* obj, Method method,
1.796 + const InA& in,
1.797 + Tuple1<OutA>* out) {
1.798 + (obj->*method)(in, &out->a);
1.799 +}
1.800 +
1.801 +template<class ObjT, class Method, class InA,
1.802 + class OutA>
1.803 +inline void DispatchToMethod(ObjT* obj, Method method,
1.804 + const Tuple1<InA>& in,
1.805 + Tuple1<OutA>* out) {
1.806 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a), &out->a);
1.807 +}
1.808 +
1.809 +template<class ObjT, class Method, class InA, class InB,
1.810 + class OutA>
1.811 +inline void DispatchToMethod(ObjT* obj, Method method,
1.812 + const Tuple2<InA, InB>& in,
1.813 + Tuple1<OutA>* out) {
1.814 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.815 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.816 + &out->a);
1.817 +}
1.818 +
1.819 +template<class ObjT, class Method, class InA, class InB, class InC,
1.820 + class OutA>
1.821 +inline void DispatchToMethod(ObjT* obj, Method method,
1.822 + const Tuple3<InA, InB, InC>& in,
1.823 + Tuple1<OutA>* out) {
1.824 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.825 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.826 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.827 + &out->a);
1.828 +}
1.829 +
1.830 +template<class ObjT, class Method, class InA, class InB, class InC, class InD,
1.831 + class OutA>
1.832 +inline void DispatchToMethod(ObjT* obj, Method method,
1.833 + const Tuple4<InA, InB, InC, InD>& in,
1.834 + Tuple1<OutA>* out) {
1.835 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.836 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.837 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.838 + base::internal::UnwrapTraits<InD>::Unwrap(in.d),
1.839 + &out->a);
1.840 +}
1.841 +
1.842 +template<class ObjT, class Method, class InA, class InB, class InC, class InD,
1.843 + class InE, class OutA>
1.844 +inline void DispatchToMethod(ObjT* obj, Method method,
1.845 + const Tuple5<InA, InB, InC, InD, InE>& in,
1.846 + Tuple1<OutA>* out) {
1.847 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.848 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.849 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.850 + base::internal::UnwrapTraits<InD>::Unwrap(in.d),
1.851 + base::internal::UnwrapTraits<InE>::Unwrap(in.e),
1.852 + &out->a);
1.853 +}
1.854 +
1.855 +template<class ObjT, class Method,
1.856 + class InA, class InB, class InC, class InD, class InE, class InF,
1.857 + class OutA>
1.858 +inline void DispatchToMethod(ObjT* obj, Method method,
1.859 + const Tuple6<InA, InB, InC, InD, InE, InF>& in,
1.860 + Tuple1<OutA>* out) {
1.861 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.862 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.863 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.864 + base::internal::UnwrapTraits<InD>::Unwrap(in.d),
1.865 + base::internal::UnwrapTraits<InE>::Unwrap(in.e),
1.866 + base::internal::UnwrapTraits<InF>::Unwrap(in.f),
1.867 + &out->a);
1.868 +}
1.869 +
1.870 +// Dispatchers with 2 out params.
1.871 +
1.872 +template<class ObjT, class Method,
1.873 + class OutA, class OutB>
1.874 +inline void DispatchToMethod(ObjT* obj, Method method,
1.875 + const Tuple0& in,
1.876 + Tuple2<OutA, OutB>* out) {
1.877 + (obj->*method)(&out->a, &out->b);
1.878 +}
1.879 +
1.880 +template<class ObjT, class Method, class InA,
1.881 + class OutA, class OutB>
1.882 +inline void DispatchToMethod(ObjT* obj, Method method,
1.883 + const InA& in,
1.884 + Tuple2<OutA, OutB>* out) {
1.885 + (obj->*method)(in, &out->a, &out->b);
1.886 +}
1.887 +
1.888 +template<class ObjT, class Method, class InA,
1.889 + class OutA, class OutB>
1.890 +inline void DispatchToMethod(ObjT* obj, Method method,
1.891 + const Tuple1<InA>& in,
1.892 + Tuple2<OutA, OutB>* out) {
1.893 + (obj->*method)(
1.894 + base::internal::UnwrapTraits<InA>::Unwrap(in.a), &out->a, &out->b);
1.895 +}
1.896 +
1.897 +template<class ObjT, class Method, class InA, class InB,
1.898 + class OutA, class OutB>
1.899 +inline void DispatchToMethod(ObjT* obj, Method method,
1.900 + const Tuple2<InA, InB>& in,
1.901 + Tuple2<OutA, OutB>* out) {
1.902 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.903 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.904 + &out->a,
1.905 + &out->b);
1.906 +}
1.907 +
1.908 +template<class ObjT, class Method, class InA, class InB, class InC,
1.909 + class OutA, class OutB>
1.910 +inline void DispatchToMethod(ObjT* obj, Method method,
1.911 + const Tuple3<InA, InB, InC>& in,
1.912 + Tuple2<OutA, OutB>* out) {
1.913 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.914 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.915 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.916 + &out->a,
1.917 + &out->b);
1.918 +}
1.919 +
1.920 +template<class ObjT, class Method, class InA, class InB, class InC, class InD,
1.921 + class OutA, class OutB>
1.922 +inline void DispatchToMethod(ObjT* obj, Method method,
1.923 + const Tuple4<InA, InB, InC, InD>& in,
1.924 + Tuple2<OutA, OutB>* out) {
1.925 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.926 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.927 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.928 + base::internal::UnwrapTraits<InD>::Unwrap(in.d),
1.929 + &out->a,
1.930 + &out->b);
1.931 +}
1.932 +
1.933 +template<class ObjT, class Method,
1.934 + class InA, class InB, class InC, class InD, class InE,
1.935 + class OutA, class OutB>
1.936 +inline void DispatchToMethod(ObjT* obj, Method method,
1.937 + const Tuple5<InA, InB, InC, InD, InE>& in,
1.938 + Tuple2<OutA, OutB>* out) {
1.939 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.940 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.941 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.942 + base::internal::UnwrapTraits<InD>::Unwrap(in.d),
1.943 + base::internal::UnwrapTraits<InE>::Unwrap(in.e),
1.944 + &out->a,
1.945 + &out->b);
1.946 +}
1.947 +
1.948 +template<class ObjT, class Method,
1.949 + class InA, class InB, class InC, class InD, class InE, class InF,
1.950 + class OutA, class OutB>
1.951 +inline void DispatchToMethod(ObjT* obj, Method method,
1.952 + const Tuple6<InA, InB, InC, InD, InE, InF>& in,
1.953 + Tuple2<OutA, OutB>* out) {
1.954 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.955 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.956 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.957 + base::internal::UnwrapTraits<InD>::Unwrap(in.d),
1.958 + base::internal::UnwrapTraits<InE>::Unwrap(in.e),
1.959 + base::internal::UnwrapTraits<InF>::Unwrap(in.f),
1.960 + &out->a,
1.961 + &out->b);
1.962 +}
1.963 +
1.964 +// Dispatchers with 3 out params.
1.965 +
1.966 +template<class ObjT, class Method,
1.967 + class OutA, class OutB, class OutC>
1.968 +inline void DispatchToMethod(ObjT* obj, Method method,
1.969 + const Tuple0& in,
1.970 + Tuple3<OutA, OutB, OutC>* out) {
1.971 + (obj->*method)(&out->a, &out->b, &out->c);
1.972 +}
1.973 +
1.974 +template<class ObjT, class Method, class InA,
1.975 + class OutA, class OutB, class OutC>
1.976 +inline void DispatchToMethod(ObjT* obj, Method method,
1.977 + const InA& in,
1.978 + Tuple3<OutA, OutB, OutC>* out) {
1.979 + (obj->*method)(in, &out->a, &out->b, &out->c);
1.980 +}
1.981 +
1.982 +template<class ObjT, class Method, class InA,
1.983 + class OutA, class OutB, class OutC>
1.984 +inline void DispatchToMethod(ObjT* obj, Method method,
1.985 + const Tuple1<InA>& in,
1.986 + Tuple3<OutA, OutB, OutC>* out) {
1.987 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.988 + &out->a,
1.989 + &out->b,
1.990 + &out->c);
1.991 +}
1.992 +
1.993 +template<class ObjT, class Method, class InA, class InB,
1.994 + class OutA, class OutB, class OutC>
1.995 +inline void DispatchToMethod(ObjT* obj, Method method,
1.996 + const Tuple2<InA, InB>& in,
1.997 + Tuple3<OutA, OutB, OutC>* out) {
1.998 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.999 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.1000 + &out->a,
1.1001 + &out->b,
1.1002 + &out->c);
1.1003 +}
1.1004 +
1.1005 +template<class ObjT, class Method, class InA, class InB, class InC,
1.1006 + class OutA, class OutB, class OutC>
1.1007 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1008 + const Tuple3<InA, InB, InC>& in,
1.1009 + Tuple3<OutA, OutB, OutC>* out) {
1.1010 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.1011 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.1012 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.1013 + &out->a,
1.1014 + &out->b,
1.1015 + &out->c);
1.1016 +}
1.1017 +
1.1018 +template<class ObjT, class Method, class InA, class InB, class InC, class InD,
1.1019 + class OutA, class OutB, class OutC>
1.1020 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1021 + const Tuple4<InA, InB, InC, InD>& in,
1.1022 + Tuple3<OutA, OutB, OutC>* out) {
1.1023 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.1024 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.1025 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.1026 + base::internal::UnwrapTraits<InD>::Unwrap(in.d),
1.1027 + &out->a,
1.1028 + &out->b,
1.1029 + &out->c);
1.1030 +}
1.1031 +
1.1032 +template<class ObjT, class Method,
1.1033 + class InA, class InB, class InC, class InD, class InE,
1.1034 + class OutA, class OutB, class OutC>
1.1035 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1036 + const Tuple5<InA, InB, InC, InD, InE>& in,
1.1037 + Tuple3<OutA, OutB, OutC>* out) {
1.1038 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.1039 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.1040 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.1041 + base::internal::UnwrapTraits<InD>::Unwrap(in.d),
1.1042 + base::internal::UnwrapTraits<InE>::Unwrap(in.e),
1.1043 + &out->a,
1.1044 + &out->b,
1.1045 + &out->c);
1.1046 +}
1.1047 +
1.1048 +template<class ObjT, class Method,
1.1049 + class InA, class InB, class InC, class InD, class InE, class InF,
1.1050 + class OutA, class OutB, class OutC>
1.1051 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1052 + const Tuple6<InA, InB, InC, InD, InE, InF>& in,
1.1053 + Tuple3<OutA, OutB, OutC>* out) {
1.1054 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.1055 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.1056 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.1057 + base::internal::UnwrapTraits<InD>::Unwrap(in.d),
1.1058 + base::internal::UnwrapTraits<InE>::Unwrap(in.e),
1.1059 + base::internal::UnwrapTraits<InF>::Unwrap(in.f),
1.1060 + &out->a,
1.1061 + &out->b,
1.1062 + &out->c);
1.1063 +}
1.1064 +
1.1065 +// Dispatchers with 4 out params.
1.1066 +
1.1067 +template<class ObjT, class Method,
1.1068 + class OutA, class OutB, class OutC, class OutD>
1.1069 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1070 + const Tuple0& in,
1.1071 + Tuple4<OutA, OutB, OutC, OutD>* out) {
1.1072 + (obj->*method)(&out->a, &out->b, &out->c, &out->d);
1.1073 +}
1.1074 +
1.1075 +template<class ObjT, class Method, class InA,
1.1076 + class OutA, class OutB, class OutC, class OutD>
1.1077 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1078 + const InA& in,
1.1079 + Tuple4<OutA, OutB, OutC, OutD>* out) {
1.1080 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in),
1.1081 + &out->a,
1.1082 + &out->b,
1.1083 + &out->c,
1.1084 + &out->d);
1.1085 +}
1.1086 +
1.1087 +template<class ObjT, class Method, class InA,
1.1088 + class OutA, class OutB, class OutC, class OutD>
1.1089 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1090 + const Tuple1<InA>& in,
1.1091 + Tuple4<OutA, OutB, OutC, OutD>* out) {
1.1092 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.1093 + &out->a,
1.1094 + &out->b,
1.1095 + &out->c,
1.1096 + &out->d);
1.1097 +}
1.1098 +
1.1099 +template<class ObjT, class Method, class InA, class InB,
1.1100 + class OutA, class OutB, class OutC, class OutD>
1.1101 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1102 + const Tuple2<InA, InB>& in,
1.1103 + Tuple4<OutA, OutB, OutC, OutD>* out) {
1.1104 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.1105 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.1106 + &out->a,
1.1107 + &out->b,
1.1108 + &out->c,
1.1109 + &out->d);
1.1110 +}
1.1111 +
1.1112 +template<class ObjT, class Method, class InA, class InB, class InC,
1.1113 + class OutA, class OutB, class OutC, class OutD>
1.1114 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1115 + const Tuple3<InA, InB, InC>& in,
1.1116 + Tuple4<OutA, OutB, OutC, OutD>* out) {
1.1117 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.1118 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.1119 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.1120 + &out->a,
1.1121 + &out->b,
1.1122 + &out->c,
1.1123 + &out->d);
1.1124 +}
1.1125 +
1.1126 +template<class ObjT, class Method, class InA, class InB, class InC, class InD,
1.1127 + class OutA, class OutB, class OutC, class OutD>
1.1128 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1129 + const Tuple4<InA, InB, InC, InD>& in,
1.1130 + Tuple4<OutA, OutB, OutC, OutD>* out) {
1.1131 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.1132 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.1133 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.1134 + base::internal::UnwrapTraits<InD>::Unwrap(in.d),
1.1135 + &out->a,
1.1136 + &out->b,
1.1137 + &out->c,
1.1138 + &out->d);
1.1139 +}
1.1140 +
1.1141 +template<class ObjT, class Method,
1.1142 + class InA, class InB, class InC, class InD, class InE,
1.1143 + class OutA, class OutB, class OutC, class OutD>
1.1144 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1145 + const Tuple5<InA, InB, InC, InD, InE>& in,
1.1146 + Tuple4<OutA, OutB, OutC, OutD>* out) {
1.1147 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.1148 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.1149 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.1150 + base::internal::UnwrapTraits<InD>::Unwrap(in.d),
1.1151 + base::internal::UnwrapTraits<InE>::Unwrap(in.e),
1.1152 + &out->a,
1.1153 + &out->b,
1.1154 + &out->c,
1.1155 + &out->d);
1.1156 +}
1.1157 +
1.1158 +template<class ObjT, class Method,
1.1159 + class InA, class InB, class InC, class InD, class InE, class InF,
1.1160 + class OutA, class OutB, class OutC, class OutD>
1.1161 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1162 + const Tuple6<InA, InB, InC, InD, InE, InF>& in,
1.1163 + Tuple4<OutA, OutB, OutC, OutD>* out) {
1.1164 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.1165 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.1166 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.1167 + base::internal::UnwrapTraits<InD>::Unwrap(in.d),
1.1168 + base::internal::UnwrapTraits<InE>::Unwrap(in.e),
1.1169 + base::internal::UnwrapTraits<InF>::Unwrap(in.f),
1.1170 + &out->a,
1.1171 + &out->b,
1.1172 + &out->c,
1.1173 + &out->d);
1.1174 +}
1.1175 +
1.1176 +// Dispatchers with 5 out params.
1.1177 +
1.1178 +template<class ObjT, class Method,
1.1179 + class OutA, class OutB, class OutC, class OutD, class OutE>
1.1180 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1181 + const Tuple0& in,
1.1182 + Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
1.1183 + (obj->*method)(&out->a, &out->b, &out->c, &out->d, &out->e);
1.1184 +}
1.1185 +
1.1186 +template<class ObjT, class Method, class InA,
1.1187 + class OutA, class OutB, class OutC, class OutD, class OutE>
1.1188 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1189 + const InA& in,
1.1190 + Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
1.1191 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in),
1.1192 + &out->a,
1.1193 + &out->b,
1.1194 + &out->c,
1.1195 + &out->d,
1.1196 + &out->e);
1.1197 +}
1.1198 +
1.1199 +template<class ObjT, class Method, class InA,
1.1200 + class OutA, class OutB, class OutC, class OutD, class OutE>
1.1201 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1202 + const Tuple1<InA>& in,
1.1203 + Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
1.1204 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.1205 + &out->a,
1.1206 + &out->b,
1.1207 + &out->c,
1.1208 + &out->d,
1.1209 + &out->e);
1.1210 +}
1.1211 +
1.1212 +template<class ObjT, class Method, class InA, class InB,
1.1213 + class OutA, class OutB, class OutC, class OutD, class OutE>
1.1214 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1215 + const Tuple2<InA, InB>& in,
1.1216 + Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
1.1217 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.1218 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.1219 + &out->a,
1.1220 + &out->b,
1.1221 + &out->c,
1.1222 + &out->d,
1.1223 + &out->e);
1.1224 +}
1.1225 +
1.1226 +template<class ObjT, class Method, class InA, class InB, class InC,
1.1227 + class OutA, class OutB, class OutC, class OutD, class OutE>
1.1228 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1229 + const Tuple3<InA, InB, InC>& in,
1.1230 + Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
1.1231 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.1232 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.1233 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.1234 + &out->a,
1.1235 + &out->b,
1.1236 + &out->c,
1.1237 + &out->d,
1.1238 + &out->e);
1.1239 +}
1.1240 +
1.1241 +template<class ObjT, class Method, class InA, class InB, class InC, class InD,
1.1242 + class OutA, class OutB, class OutC, class OutD, class OutE>
1.1243 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1244 + const Tuple4<InA, InB, InC, InD>& in,
1.1245 + Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
1.1246 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.1247 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.1248 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.1249 + base::internal::UnwrapTraits<InD>::Unwrap(in.d),
1.1250 + &out->a,
1.1251 + &out->b,
1.1252 + &out->c,
1.1253 + &out->d,
1.1254 + &out->e);
1.1255 +}
1.1256 +
1.1257 +template<class ObjT, class Method,
1.1258 + class InA, class InB, class InC, class InD, class InE,
1.1259 + class OutA, class OutB, class OutC, class OutD, class OutE>
1.1260 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1261 + const Tuple5<InA, InB, InC, InD, InE>& in,
1.1262 + Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
1.1263 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.1264 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.1265 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.1266 + base::internal::UnwrapTraits<InD>::Unwrap(in.d),
1.1267 + base::internal::UnwrapTraits<InE>::Unwrap(in.e),
1.1268 + &out->a,
1.1269 + &out->b,
1.1270 + &out->c,
1.1271 + &out->d,
1.1272 + &out->e);
1.1273 +}
1.1274 +
1.1275 +template<class ObjT, class Method,
1.1276 + class InA, class InB, class InC, class InD, class InE, class InF,
1.1277 + class OutA, class OutB, class OutC, class OutD, class OutE>
1.1278 +inline void DispatchToMethod(ObjT* obj, Method method,
1.1279 + const Tuple6<InA, InB, InC, InD, InE, InF>& in,
1.1280 + Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
1.1281 + (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
1.1282 + base::internal::UnwrapTraits<InB>::Unwrap(in.b),
1.1283 + base::internal::UnwrapTraits<InC>::Unwrap(in.c),
1.1284 + base::internal::UnwrapTraits<InD>::Unwrap(in.d),
1.1285 + base::internal::UnwrapTraits<InE>::Unwrap(in.e),
1.1286 + base::internal::UnwrapTraits<InF>::Unwrap(in.f),
1.1287 + &out->a,
1.1288 + &out->b,
1.1289 + &out->c,
1.1290 + &out->d,
1.1291 + &out->e);
1.1292 +}
1.1293 +
1.1294 +#endif // BASE_TUPLE_H__
