1 : // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : // A Tuple is a generic templatized container, similar in concept to std::pair.
6 : // There are classes Tuple0 to Tuple6, cooresponding to the number of elements
7 : // it contains. The convenient MakeTuple() function takes 0 to 6 arguments,
8 : // and will construct and return the appropriate Tuple object. The functions
9 : // DispatchToMethod and DispatchToFunction take a function pointer or instance
10 : // and method pointer, and unpack a tuple into arguments to the call.
11 : //
12 : // Tuple elements are copied by value, and stored in the tuple. See the unit
13 : // tests for more details of how/when the values are copied.
14 : //
15 : // Example usage:
16 : // // These two methods of creating a Tuple are identical.
17 : // Tuple2<int, const char*> tuple_a(1, "wee");
18 : // Tuple2<int, const char*> tuple_b = MakeTuple(1, "wee");
19 : //
20 : // void SomeFunc(int a, const char* b) { }
21 : // DispatchToFunction(&SomeFunc, tuple_a); // SomeFunc(1, "wee")
22 : // DispatchToFunction(
23 : // &SomeFunc, MakeTuple(10, "foo")); // SomeFunc(10, "foo")
24 : //
25 : // struct { void SomeMeth(int a, int b, int c) { } } foo;
26 : // DispatchToMethod(&foo, &Foo::SomeMeth, MakeTuple(1, 2, 3));
27 : // // foo->SomeMeth(1, 2, 3);
28 :
29 : #ifndef BASE_TUPLE_H__
30 : #define BASE_TUPLE_H__
31 :
32 : // Traits ----------------------------------------------------------------------
33 : //
34 : // A simple traits class for tuple arguments.
35 : //
36 : // ValueType: the bare, nonref version of a type (same as the type for nonrefs).
37 : // RefType: the ref version of a type (same as the type for refs).
38 : // ParamType: what type to pass to functions (refs should not be constified).
39 :
40 : template <class P>
41 : struct TupleTraits {
42 : typedef P ValueType;
43 : typedef P& RefType;
44 : typedef const P& ParamType;
45 : };
46 :
47 : template <class P>
48 : struct TupleTraits<P&> {
49 : typedef P ValueType;
50 : typedef P& RefType;
51 : typedef P& ParamType;
52 : };
53 :
54 : // Tuple -----------------------------------------------------------------------
55 : //
56 : // This set of classes is useful for bundling 0 or more heterogeneous data types
57 : // into a single variable. The advantage of this is that it greatly simplifies
58 : // function objects that need to take an arbitrary number of parameters; see
59 : // RunnableMethod and IPC::MessageWithTuple.
60 : //
61 : // Tuple0 is supplied to act as a 'void' type. It can be used, for example,
62 : // when dispatching to a function that accepts no arguments (see the
63 : // Dispatchers below).
64 : // Tuple1<A> is rarely useful. One such use is when A is non-const ref that you
65 : // want filled by the dispatchee, and the tuple is merely a container for that
66 : // output (a "tier"). See MakeRefTuple and its usages.
67 :
68 : struct Tuple0 {
69 : typedef Tuple0 ValueTuple;
70 : typedef Tuple0 RefTuple;
71 : };
72 :
73 : template <class A>
74 0 : struct Tuple1 {
75 : public:
76 : typedef A TypeA;
77 : typedef Tuple1<typename TupleTraits<A>::ValueType> ValueTuple;
78 : typedef Tuple1<typename TupleTraits<A>::RefType> RefTuple;
79 :
80 : Tuple1() {}
81 0 : explicit Tuple1(typename TupleTraits<A>::ParamType a) : a(a) {}
82 :
83 : A a;
84 : };
85 :
86 : template <class A, class B>
87 0 : struct Tuple2 {
88 : public:
89 : typedef A TypeA;
90 : typedef B TypeB;
91 : typedef Tuple2<typename TupleTraits<A>::ValueType,
92 : typename TupleTraits<B>::ValueType> ValueTuple;
93 : typedef Tuple2<typename TupleTraits<A>::RefType,
94 : typename TupleTraits<B>::RefType> RefTuple;
95 :
96 : Tuple2() {}
97 0 : Tuple2(typename TupleTraits<A>::ParamType a,
98 : typename TupleTraits<B>::ParamType b)
99 0 : : a(a), b(b) {
100 0 : }
101 :
102 : A a;
103 : B b;
104 : };
105 :
106 : template <class A, class B, class C>
107 : struct Tuple3 {
108 : public:
109 : typedef A TypeA;
110 : typedef B TypeB;
111 : typedef C TypeC;
112 : typedef Tuple3<typename TupleTraits<A>::ValueType,
113 : typename TupleTraits<B>::ValueType,
114 : typename TupleTraits<C>::ValueType> ValueTuple;
115 : typedef Tuple3<typename TupleTraits<A>::RefType,
116 : typename TupleTraits<B>::RefType,
117 : typename TupleTraits<C>::RefType> RefTuple;
118 :
119 : Tuple3() {}
120 0 : Tuple3(typename TupleTraits<A>::ParamType a,
121 : typename TupleTraits<B>::ParamType b,
122 : typename TupleTraits<C>::ParamType c)
123 0 : : a(a), b(b), c(c){
124 0 : }
125 :
126 : A a;
127 : B b;
128 : C c;
129 : };
130 :
131 : template <class A, class B, class C, class D>
132 : struct Tuple4 {
133 : public:
134 : typedef A TypeA;
135 : typedef B TypeB;
136 : typedef C TypeC;
137 : typedef D TypeD;
138 : typedef Tuple4<typename TupleTraits<A>::ValueType,
139 : typename TupleTraits<B>::ValueType,
140 : typename TupleTraits<C>::ValueType,
141 : typename TupleTraits<D>::ValueType> ValueTuple;
142 : typedef Tuple4<typename TupleTraits<A>::RefType,
143 : typename TupleTraits<B>::RefType,
144 : typename TupleTraits<C>::RefType,
145 : typename TupleTraits<D>::RefType> RefTuple;
146 :
147 : Tuple4() {}
148 : Tuple4(typename TupleTraits<A>::ParamType a,
149 : typename TupleTraits<B>::ParamType b,
150 : typename TupleTraits<C>::ParamType c,
151 : typename TupleTraits<D>::ParamType d)
152 : : a(a), b(b), c(c), d(d) {
153 : }
154 :
155 : A a;
156 : B b;
157 : C c;
158 : D d;
159 : };
160 :
161 : template <class A, class B, class C, class D, class E>
162 : struct Tuple5 {
163 : public:
164 : typedef A TypeA;
165 : typedef B TypeB;
166 : typedef C TypeC;
167 : typedef D TypeD;
168 : typedef E TypeE;
169 : typedef Tuple5<typename TupleTraits<A>::ValueType,
170 : typename TupleTraits<B>::ValueType,
171 : typename TupleTraits<C>::ValueType,
172 : typename TupleTraits<D>::ValueType,
173 : typename TupleTraits<E>::ValueType> ValueTuple;
174 : typedef Tuple5<typename TupleTraits<A>::RefType,
175 : typename TupleTraits<B>::RefType,
176 : typename TupleTraits<C>::RefType,
177 : typename TupleTraits<D>::RefType,
178 : typename TupleTraits<E>::RefType> RefTuple;
179 :
180 : Tuple5() {}
181 : Tuple5(typename TupleTraits<A>::ParamType a,
182 : typename TupleTraits<B>::ParamType b,
183 : typename TupleTraits<C>::ParamType c,
184 : typename TupleTraits<D>::ParamType d,
185 : typename TupleTraits<E>::ParamType e)
186 : : a(a), b(b), c(c), d(d), e(e) {
187 : }
188 :
189 : A a;
190 : B b;
191 : C c;
192 : D d;
193 : E e;
194 : };
195 :
196 : template <class A, class B, class C, class D, class E, class F>
197 : struct Tuple6 {
198 : public:
199 : typedef A TypeA;
200 : typedef B TypeB;
201 : typedef C TypeC;
202 : typedef D TypeD;
203 : typedef E TypeE;
204 : typedef F TypeF;
205 : typedef Tuple6<typename TupleTraits<A>::ValueType,
206 : typename TupleTraits<B>::ValueType,
207 : typename TupleTraits<C>::ValueType,
208 : typename TupleTraits<D>::ValueType,
209 : typename TupleTraits<E>::ValueType,
210 : typename TupleTraits<F>::ValueType> ValueTuple;
211 : typedef Tuple6<typename TupleTraits<A>::RefType,
212 : typename TupleTraits<B>::RefType,
213 : typename TupleTraits<C>::RefType,
214 : typename TupleTraits<D>::RefType,
215 : typename TupleTraits<E>::RefType,
216 : typename TupleTraits<F>::RefType> RefTuple;
217 :
218 : Tuple6() {}
219 : Tuple6(typename TupleTraits<A>::ParamType a,
220 : typename TupleTraits<B>::ParamType b,
221 : typename TupleTraits<C>::ParamType c,
222 : typename TupleTraits<D>::ParamType d,
223 : typename TupleTraits<E>::ParamType e,
224 : typename TupleTraits<F>::ParamType f)
225 : : a(a), b(b), c(c), d(d), e(e), f(f) {
226 : }
227 :
228 : A a;
229 : B b;
230 : C c;
231 : D d;
232 : E e;
233 : F f;
234 : };
235 :
236 : template <class A, class B, class C, class D, class E, class F, class G>
237 : struct Tuple7 {
238 : public:
239 : typedef A TypeA;
240 : typedef B TypeB;
241 : typedef C TypeC;
242 : typedef D TypeD;
243 : typedef E TypeE;
244 : typedef F TypeF;
245 : typedef G TypeG;
246 : typedef Tuple7<typename TupleTraits<A>::ValueType,
247 : typename TupleTraits<B>::ValueType,
248 : typename TupleTraits<C>::ValueType,
249 : typename TupleTraits<D>::ValueType,
250 : typename TupleTraits<E>::ValueType,
251 : typename TupleTraits<F>::ValueType,
252 : typename TupleTraits<G>::ValueType> ValueTuple;
253 : typedef Tuple7<typename TupleTraits<A>::RefType,
254 : typename TupleTraits<B>::RefType,
255 : typename TupleTraits<C>::RefType,
256 : typename TupleTraits<D>::RefType,
257 : typename TupleTraits<E>::RefType,
258 : typename TupleTraits<F>::RefType,
259 : typename TupleTraits<G>::RefType> RefTuple;
260 :
261 : Tuple7() {}
262 : Tuple7(typename TupleTraits<A>::ParamType a,
263 : typename TupleTraits<B>::ParamType b,
264 : typename TupleTraits<C>::ParamType c,
265 : typename TupleTraits<D>::ParamType d,
266 : typename TupleTraits<E>::ParamType e,
267 : typename TupleTraits<F>::ParamType f,
268 : typename TupleTraits<G>::ParamType g)
269 : : a(a), b(b), c(c), d(d), e(e), f(f), g(g) {
270 : }
271 :
272 : A a;
273 : B b;
274 : C c;
275 : D d;
276 : E e;
277 : F f;
278 : G g;
279 : };
280 :
281 : // Tuple creators -------------------------------------------------------------
282 : //
283 : // Helper functions for constructing tuples while inferring the template
284 : // argument types.
285 :
286 1 : inline Tuple0 MakeTuple() {
287 1 : return Tuple0();
288 : }
289 :
290 : template <class A>
291 0 : inline Tuple1<A> MakeTuple(const A& a) {
292 0 : return Tuple1<A>(a);
293 : }
294 :
295 : template <class A, class B>
296 0 : inline Tuple2<A, B> MakeTuple(const A& a, const B& b) {
297 0 : return Tuple2<A, B>(a, b);
298 : }
299 :
300 : template <class A, class B, class C>
301 0 : inline Tuple3<A, B, C> MakeTuple(const A& a, const B& b, const C& c) {
302 0 : return Tuple3<A, B, C>(a, b, c);
303 : }
304 :
305 : template <class A, class B, class C, class D>
306 : inline Tuple4<A, B, C, D> MakeTuple(const A& a, const B& b, const C& c,
307 : const D& d) {
308 : return Tuple4<A, B, C, D>(a, b, c, d);
309 : }
310 :
311 : template <class A, class B, class C, class D, class E>
312 : inline Tuple5<A, B, C, D, E> MakeTuple(const A& a, const B& b, const C& c,
313 : const D& d, const E& e) {
314 : return Tuple5<A, B, C, D, E>(a, b, c, d, e);
315 : }
316 :
317 : template <class A, class B, class C, class D, class E, class F>
318 : inline Tuple6<A, B, C, D, E, F> MakeTuple(const A& a, const B& b, const C& c,
319 : const D& d, const E& e, const F& f) {
320 : return Tuple6<A, B, C, D, E, F>(a, b, c, d, e, f);
321 : }
322 :
323 : template <class A, class B, class C, class D, class E, class F, class G>
324 : inline Tuple7<A, B, C, D, E, F, G> MakeTuple(const A& a, const B& b, const C& c,
325 : const D& d, const E& e, const F& f,
326 : const G& g) {
327 : return Tuple7<A, B, C, D, E, F, G>(a, b, c, d, e, f, g);
328 : }
329 :
330 : // The following set of helpers make what Boost refers to as "Tiers" - a tuple
331 : // of references.
332 :
333 : template <class A>
334 : inline Tuple1<A&> MakeRefTuple(A& a) {
335 : return Tuple1<A&>(a);
336 : }
337 :
338 : template <class A, class B>
339 : inline Tuple2<A&, B&> MakeRefTuple(A& a, B& b) {
340 : return Tuple2<A&, B&>(a, b);
341 : }
342 :
343 : template <class A, class B, class C>
344 : inline Tuple3<A&, B&, C&> MakeRefTuple(A& a, B& b, C& c) {
345 : return Tuple3<A&, B&, C&>(a, b, c);
346 : }
347 :
348 : template <class A, class B, class C, class D>
349 : inline Tuple4<A&, B&, C&, D&> MakeRefTuple(A& a, B& b, C& c, D& d) {
350 : return Tuple4<A&, B&, C&, D&>(a, b, c, d);
351 : }
352 :
353 : template <class A, class B, class C, class D, class E>
354 : inline Tuple5<A&, B&, C&, D&, E&> MakeRefTuple(A& a, B& b, C& c, D& d, E& e) {
355 : return Tuple5<A&, B&, C&, D&, E&>(a, b, c, d, e);
356 : }
357 :
358 : template <class A, class B, class C, class D, class E, class F>
359 : inline Tuple6<A&, B&, C&, D&, E&, F&> MakeRefTuple(A& a, B& b, C& c, D& d, E& e,
360 : F& f) {
361 : return Tuple6<A&, B&, C&, D&, E&, F&>(a, b, c, d, e, f);
362 : }
363 :
364 : template <class A, class B, class C, class D, class E, class F, class G>
365 : inline Tuple7<A&, B&, C&, D&, E&, F&, G&> MakeRefTuple(A& a, B& b, C& c, D& d,
366 : E& e, F& f, G& g) {
367 : return Tuple7<A&, B&, C&, D&, E&, F&, G&>(a, b, c, d, e, f, g);
368 : }
369 :
370 : // Dispatchers ----------------------------------------------------------------
371 : //
372 : // Helper functions that call the given method on an object, with the unpacked
373 : // tuple arguments. Notice that they all have the same number of arguments,
374 : // so you need only write:
375 : // DispatchToMethod(object, &Object::method, args);
376 : // This is very useful for templated dispatchers, since they don't need to know
377 : // what type |args| is.
378 :
379 : // Non-Static Dispatchers with no out params.
380 :
381 : template <class ObjT, class Method>
382 0 : inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& arg) {
383 0 : (obj->*method)();
384 0 : }
385 :
386 : template <class ObjT, class Method, class A>
387 : inline void DispatchToMethod(ObjT* obj, Method method, const A& arg) {
388 : (obj->*method)(arg);
389 : }
390 :
391 : template <class ObjT, class Method, class A>
392 0 : inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1<A>& arg) {
393 0 : (obj->*method)(arg.a);
394 0 : }
395 :
396 : template<class ObjT, class Method, class A, class B>
397 0 : inline void DispatchToMethod(ObjT* obj,
398 : Method method,
399 : const Tuple2<A, B>& arg) {
400 0 : (obj->*method)(arg.a, arg.b);
401 0 : }
402 :
403 : template<class ObjT, class Method, class A, class B, class C>
404 0 : inline void DispatchToMethod(ObjT* obj, Method method,
405 : const Tuple3<A, B, C>& arg) {
406 0 : (obj->*method)(arg.a, arg.b, arg.c);
407 0 : }
408 :
409 : template<class ObjT, class Method, class A, class B, class C, class D>
410 : inline void DispatchToMethod(ObjT* obj, Method method,
411 : const Tuple4<A, B, C, D>& arg) {
412 : (obj->*method)(arg.a, arg.b, arg.c, arg.d);
413 : }
414 :
415 : template<class ObjT, class Method, class A, class B, class C, class D, class E>
416 : inline void DispatchToMethod(ObjT* obj, Method method,
417 : const Tuple5<A, B, C, D, E>& arg) {
418 : (obj->*method)(arg.a, arg.b, arg.c, arg.d, arg.e);
419 : }
420 :
421 : template<class ObjT, class Method, class A, class B, class C, class D, class E,
422 : class F>
423 : inline void DispatchToMethod(ObjT* obj, Method method,
424 : const Tuple6<A, B, C, D, E, F>& arg) {
425 : (obj->*method)(arg.a, arg.b, arg.c, arg.d, arg.e, arg.f);
426 : }
427 :
428 : template<class ObjT, class Method, class A, class B, class C, class D, class E,
429 : class F, class G>
430 : inline void DispatchToMethod(ObjT* obj, Method method,
431 : const Tuple7<A, B, C, D, E, F, G>& arg) {
432 : (obj->*method)(arg.a, arg.b, arg.c, arg.d, arg.e, arg.f, arg.g);
433 : }
434 :
435 : // Static Dispatchers with no out params.
436 :
437 : template <class Function>
438 : inline void DispatchToFunction(Function function, const Tuple0& arg) {
439 : (*function)();
440 : }
441 :
442 : template <class Function, class A>
443 : inline void DispatchToFunction(Function function, const A& arg) {
444 : (*function)(arg);
445 : }
446 :
447 : template <class Function, class A>
448 0 : inline void DispatchToFunction(Function function, const Tuple1<A>& arg) {
449 0 : (*function)(arg.a);
450 0 : }
451 :
452 : template<class Function, class A, class B>
453 : inline void DispatchToFunction(Function function, const Tuple2<A, B>& arg) {
454 : (*function)(arg.a, arg.b);
455 : }
456 :
457 : template<class Function, class A, class B, class C>
458 : inline void DispatchToFunction(Function function, const Tuple3<A, B, C>& arg) {
459 : (*function)(arg.a, arg.b, arg.c);
460 : }
461 :
462 : template<class Function, class A, class B, class C, class D>
463 : inline void DispatchToFunction(Function function,
464 : const Tuple4<A, B, C, D>& arg) {
465 : (*function)(arg.a, arg.b, arg.c, arg.d);
466 : }
467 :
468 : template<class Function, class A, class B, class C, class D, class E>
469 : inline void DispatchToFunction(Function function,
470 : const Tuple5<A, B, C, D, E>& arg) {
471 : (*function)(arg.a, arg.b, arg.c, arg.d, arg.e);
472 : }
473 :
474 : template<class Function, class A, class B, class C, class D, class E, class F>
475 : inline void DispatchToFunction(Function function,
476 : const Tuple6<A, B, C, D, E, F>& arg) {
477 : (*function)(arg.a, arg.b, arg.c, arg.d, arg.e, arg.f);
478 : }
479 :
480 : // Dispatchers with 0 out param (as a Tuple0).
481 :
482 : template <class ObjT, class Method>
483 : inline void DispatchToMethod(ObjT* obj,
484 : Method method,
485 : const Tuple0& arg, Tuple0*) {
486 : (obj->*method)();
487 : }
488 :
489 : template <class ObjT, class Method, class A>
490 : inline void DispatchToMethod(ObjT* obj, Method method, const A& arg, Tuple0*) {
491 : (obj->*method)(arg);
492 : }
493 :
494 : template <class ObjT, class Method, class A>
495 : inline void DispatchToMethod(ObjT* obj,
496 : Method method,
497 : const Tuple1<A>& arg, Tuple0*) {
498 : (obj->*method)(arg.a);
499 : }
500 :
501 : template<class ObjT, class Method, class A, class B>
502 : inline void DispatchToMethod(ObjT* obj,
503 : Method method,
504 : const Tuple2<A, B>& arg, Tuple0*) {
505 : (obj->*method)(arg.a, arg.b);
506 : }
507 :
508 : template<class ObjT, class Method, class A, class B, class C>
509 : inline void DispatchToMethod(ObjT* obj, Method method,
510 : const Tuple3<A, B, C>& arg, Tuple0*) {
511 : (obj->*method)(arg.a, arg.b, arg.c);
512 : }
513 :
514 : template<class ObjT, class Method, class A, class B, class C, class D>
515 : inline void DispatchToMethod(ObjT* obj, Method method,
516 : const Tuple4<A, B, C, D>& arg, Tuple0*) {
517 : (obj->*method)(arg.a, arg.b, arg.c, arg.d);
518 : }
519 :
520 : template<class ObjT, class Method, class A, class B, class C, class D, class E>
521 : inline void DispatchToMethod(ObjT* obj, Method method,
522 : const Tuple5<A, B, C, D, E>& arg, Tuple0*) {
523 : (obj->*method)(arg.a, arg.b, arg.c, arg.d, arg.e);
524 : }
525 :
526 : template<class ObjT, class Method, class A, class B, class C, class D, class E,
527 : class F>
528 : inline void DispatchToMethod(ObjT* obj, Method method,
529 : const Tuple6<A, B, C, D, E, F>& arg, Tuple0*) {
530 : (obj->*method)(arg.a, arg.b, arg.c, arg.d, arg.e, arg.f);
531 : }
532 :
533 : // Dispatchers with 1 out param.
534 :
535 : template<class ObjT, class Method,
536 : class OutA>
537 : inline void DispatchToMethod(ObjT* obj, Method method,
538 : const Tuple0& in,
539 : Tuple1<OutA>* out) {
540 : (obj->*method)(&out->a);
541 : }
542 :
543 : template<class ObjT, class Method, class InA,
544 : class OutA>
545 : inline void DispatchToMethod(ObjT* obj, Method method,
546 : const InA& in,
547 : Tuple1<OutA>* out) {
548 : (obj->*method)(in, &out->a);
549 : }
550 :
551 : template<class ObjT, class Method, class InA,
552 : class OutA>
553 : inline void DispatchToMethod(ObjT* obj, Method method,
554 : const Tuple1<InA>& in,
555 : Tuple1<OutA>* out) {
556 : (obj->*method)(in.a, &out->a);
557 : }
558 :
559 : template<class ObjT, class Method, class InA, class InB,
560 : class OutA>
561 : inline void DispatchToMethod(ObjT* obj, Method method,
562 : const Tuple2<InA, InB>& in,
563 : Tuple1<OutA>* out) {
564 : (obj->*method)(in.a, in.b, &out->a);
565 : }
566 :
567 : template<class ObjT, class Method, class InA, class InB, class InC,
568 : class OutA>
569 : inline void DispatchToMethod(ObjT* obj, Method method,
570 : const Tuple3<InA, InB, InC>& in,
571 : Tuple1<OutA>* out) {
572 : (obj->*method)(in.a, in.b, in.c, &out->a);
573 : }
574 :
575 : template<class ObjT, class Method, class InA, class InB, class InC, class InD,
576 : class OutA>
577 : inline void DispatchToMethod(ObjT* obj, Method method,
578 : const Tuple4<InA, InB, InC, InD>& in,
579 : Tuple1<OutA>* out) {
580 : (obj->*method)(in.a, in.b, in.c, in.d, &out->a);
581 : }
582 :
583 : template<class ObjT, class Method,
584 : class InA, class InB, class InC, class InD, class InE,
585 : class OutA>
586 : inline void DispatchToMethod(ObjT* obj, Method method,
587 : const Tuple5<InA, InB, InC, InD, InE>& in,
588 : Tuple1<OutA>* out) {
589 : (obj->*method)(in.a, in.b, in.c, in.d, in.e, &out->a);
590 : }
591 :
592 : template<class ObjT, class Method,
593 : class InA, class InB, class InC, class InD, class InE, class InF,
594 : class OutA>
595 : inline void DispatchToMethod(ObjT* obj, Method method,
596 : const Tuple6<InA, InB, InC, InD, InE, InF>& in,
597 : Tuple1<OutA>* out) {
598 : (obj->*method)(in.a, in.b, in.c, in.d, in.e, in.f, &out->a);
599 : }
600 :
601 : // Dispatchers with 2 out params.
602 :
603 : template<class ObjT, class Method,
604 : class OutA, class OutB>
605 : inline void DispatchToMethod(ObjT* obj, Method method,
606 : const Tuple0& in,
607 : Tuple2<OutA, OutB>* out) {
608 : (obj->*method)(&out->a, &out->b);
609 : }
610 :
611 : template<class ObjT, class Method, class InA,
612 : class OutA, class OutB>
613 : inline void DispatchToMethod(ObjT* obj, Method method,
614 : const InA& in,
615 : Tuple2<OutA, OutB>* out) {
616 : (obj->*method)(in, &out->a, &out->b);
617 : }
618 :
619 : template<class ObjT, class Method, class InA,
620 : class OutA, class OutB>
621 : inline void DispatchToMethod(ObjT* obj, Method method,
622 : const Tuple1<InA>& in,
623 : Tuple2<OutA, OutB>* out) {
624 : (obj->*method)(in.a, &out->a, &out->b);
625 : }
626 :
627 : template<class ObjT, class Method, class InA, class InB,
628 : class OutA, class OutB>
629 : inline void DispatchToMethod(ObjT* obj, Method method,
630 : const Tuple2<InA, InB>& in,
631 : Tuple2<OutA, OutB>* out) {
632 : (obj->*method)(in.a, in.b, &out->a, &out->b);
633 : }
634 :
635 : template<class ObjT, class Method, class InA, class InB, class InC,
636 : class OutA, class OutB>
637 : inline void DispatchToMethod(ObjT* obj, Method method,
638 : const Tuple3<InA, InB, InC>& in,
639 : Tuple2<OutA, OutB>* out) {
640 : (obj->*method)(in.a, in.b, in.c, &out->a, &out->b);
641 : }
642 :
643 : template<class ObjT, class Method, class InA, class InB, class InC, class InD,
644 : class OutA, class OutB>
645 : inline void DispatchToMethod(ObjT* obj, Method method,
646 : const Tuple4<InA, InB, InC, InD>& in,
647 : Tuple2<OutA, OutB>* out) {
648 : (obj->*method)(in.a, in.b, in.c, in.d, &out->a, &out->b);
649 : }
650 :
651 : template<class ObjT, class Method,
652 : class InA, class InB, class InC, class InD, class InE,
653 : class OutA, class OutB>
654 : inline void DispatchToMethod(ObjT* obj, Method method,
655 : const Tuple5<InA, InB, InC, InD, InE>& in,
656 : Tuple2<OutA, OutB>* out) {
657 : (obj->*method)(in.a, in.b, in.c, in.d, in.e, &out->a, &out->b);
658 : }
659 :
660 : template<class ObjT, class Method,
661 : class InA, class InB, class InC, class InD, class InE, class InF,
662 : class OutA, class OutB>
663 : inline void DispatchToMethod(ObjT* obj, Method method,
664 : const Tuple6<InA, InB, InC, InD, InE, InF>& in,
665 : Tuple2<OutA, OutB>* out) {
666 : (obj->*method)(in.a, in.b, in.c, in.d, in.e, in.f, &out->a, &out->b);
667 : }
668 :
669 : // Dispatchers with 3 out params.
670 :
671 : template<class ObjT, class Method,
672 : class OutA, class OutB, class OutC>
673 : inline void DispatchToMethod(ObjT* obj, Method method,
674 : const Tuple0& in,
675 : Tuple3<OutA, OutB, OutC>* out) {
676 : (obj->*method)(&out->a, &out->b, &out->c);
677 : }
678 :
679 : template<class ObjT, class Method, class InA,
680 : class OutA, class OutB, class OutC>
681 : inline void DispatchToMethod(ObjT* obj, Method method,
682 : const InA& in,
683 : Tuple3<OutA, OutB, OutC>* out) {
684 : (obj->*method)(in, &out->a, &out->b, &out->c);
685 : }
686 :
687 : template<class ObjT, class Method, class InA,
688 : class OutA, class OutB, class OutC>
689 : inline void DispatchToMethod(ObjT* obj, Method method,
690 : const Tuple1<InA>& in,
691 : Tuple3<OutA, OutB, OutC>* out) {
692 : (obj->*method)(in.a, &out->a, &out->b, &out->c);
693 : }
694 :
695 : template<class ObjT, class Method, class InA, class InB,
696 : class OutA, class OutB, class OutC>
697 : inline void DispatchToMethod(ObjT* obj, Method method,
698 : const Tuple2<InA, InB>& in,
699 : Tuple3<OutA, OutB, OutC>* out) {
700 : (obj->*method)(in.a, in.b, &out->a, &out->b, &out->c);
701 : }
702 :
703 : template<class ObjT, class Method, class InA, class InB, class InC,
704 : class OutA, class OutB, class OutC>
705 : inline void DispatchToMethod(ObjT* obj, Method method,
706 : const Tuple3<InA, InB, InC>& in,
707 : Tuple3<OutA, OutB, OutC>* out) {
708 : (obj->*method)(in.a, in.b, in.c, &out->a, &out->b, &out->c);
709 : }
710 :
711 : template<class ObjT, class Method, class InA, class InB, class InC, class InD,
712 : class OutA, class OutB, class OutC>
713 : inline void DispatchToMethod(ObjT* obj, Method method,
714 : const Tuple4<InA, InB, InC, InD>& in,
715 : Tuple3<OutA, OutB, OutC>* out) {
716 : (obj->*method)(in.a, in.b, in.c, in.d, &out->a, &out->b, &out->c);
717 : }
718 :
719 : template<class ObjT, class Method,
720 : class InA, class InB, class InC, class InD, class InE,
721 : class OutA, class OutB, class OutC>
722 : inline void DispatchToMethod(ObjT* obj, Method method,
723 : const Tuple5<InA, InB, InC, InD, InE>& in,
724 : Tuple3<OutA, OutB, OutC>* out) {
725 : (obj->*method)(in.a, in.b, in.c, in.d, in.e, &out->a, &out->b, &out->c);
726 : }
727 :
728 : template<class ObjT, class Method,
729 : class InA, class InB, class InC, class InD, class InE, class InF,
730 : class OutA, class OutB, class OutC>
731 : inline void DispatchToMethod(ObjT* obj, Method method,
732 : const Tuple6<InA, InB, InC, InD, InE, InF>& in,
733 : Tuple3<OutA, OutB, OutC>* out) {
734 : (obj->*method)(in.a, in.b, in.c, in.d, in.e, in.f, &out->a, &out->b, &out->c);
735 : }
736 :
737 : // Dispatchers with 4 out params.
738 :
739 : template<class ObjT, class Method,
740 : class OutA, class OutB, class OutC, class OutD>
741 : inline void DispatchToMethod(ObjT* obj, Method method,
742 : const Tuple0& in,
743 : Tuple4<OutA, OutB, OutC, OutD>* out) {
744 : (obj->*method)(&out->a, &out->b, &out->c, &out->d);
745 : }
746 :
747 : template<class ObjT, class Method, class InA,
748 : class OutA, class OutB, class OutC, class OutD>
749 : inline void DispatchToMethod(ObjT* obj, Method method,
750 : const InA& in,
751 : Tuple4<OutA, OutB, OutC, OutD>* out) {
752 : (obj->*method)(in, &out->a, &out->b, &out->c, &out->d);
753 : }
754 :
755 : template<class ObjT, class Method, class InA,
756 : class OutA, class OutB, class OutC, class OutD>
757 : inline void DispatchToMethod(ObjT* obj, Method method,
758 : const Tuple1<InA>& in,
759 : Tuple4<OutA, OutB, OutC, OutD>* out) {
760 : (obj->*method)(in.a, &out->a, &out->b, &out->c, &out->d);
761 : }
762 :
763 : template<class ObjT, class Method, class InA, class InB,
764 : class OutA, class OutB, class OutC, class OutD>
765 : inline void DispatchToMethod(ObjT* obj, Method method,
766 : const Tuple2<InA, InB>& in,
767 : Tuple4<OutA, OutB, OutC, OutD>* out) {
768 : (obj->*method)(in.a, in.b, &out->a, &out->b, &out->c, &out->d);
769 : }
770 :
771 : template<class ObjT, class Method, class InA, class InB, class InC,
772 : class OutA, class OutB, class OutC, class OutD>
773 : inline void DispatchToMethod(ObjT* obj, Method method,
774 : const Tuple3<InA, InB, InC>& in,
775 : Tuple4<OutA, OutB, OutC, OutD>* out) {
776 : (obj->*method)(in.a, in.b, in.c, &out->a, &out->b, &out->c, &out->d);
777 : }
778 :
779 : template<class ObjT, class Method, class InA, class InB, class InC, class InD,
780 : class OutA, class OutB, class OutC, class OutD>
781 : inline void DispatchToMethod(ObjT* obj, Method method,
782 : const Tuple4<InA, InB, InC, InD>& in,
783 : Tuple4<OutA, OutB, OutC, OutD>* out) {
784 : (obj->*method)(in.a, in.b, in.c, in.d, &out->a, &out->b, &out->c, &out->d);
785 : }
786 :
787 : template<class ObjT, class Method,
788 : class InA, class InB, class InC, class InD, class InE,
789 : class OutA, class OutB, class OutC, class OutD>
790 : inline void DispatchToMethod(ObjT* obj, Method method,
791 : const Tuple5<InA, InB, InC, InD, InE>& in,
792 : Tuple4<OutA, OutB, OutC, OutD>* out) {
793 : (obj->*method)(in.a, in.b, in.c, in.d, in.e,
794 : &out->a, &out->b, &out->c, &out->d);
795 : }
796 :
797 : template<class ObjT, class Method,
798 : class InA, class InB, class InC, class InD, class InE, class InF,
799 : class OutA, class OutB, class OutC, class OutD>
800 : inline void DispatchToMethod(ObjT* obj, Method method,
801 : const Tuple6<InA, InB, InC, InD, InE, InF>& in,
802 : Tuple4<OutA, OutB, OutC, OutD>* out) {
803 : (obj->*method)(in.a, in.b, in.c, in.d, in.e, in.f,
804 : &out->a, &out->b, &out->c, &out->d);
805 : }
806 :
807 : // Dispatchers with 5 out params.
808 :
809 : template<class ObjT, class Method,
810 : class OutA, class OutB, class OutC, class OutD, class OutE>
811 : inline void DispatchToMethod(ObjT* obj, Method method,
812 : const Tuple0& in,
813 : Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
814 : (obj->*method)(&out->a, &out->b, &out->c, &out->d, &out->e);
815 : }
816 :
817 : template<class ObjT, class Method, class InA,
818 : class OutA, class OutB, class OutC, class OutD, class OutE>
819 : inline void DispatchToMethod(ObjT* obj, Method method,
820 : const InA& in,
821 : Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
822 : (obj->*method)(in, &out->a, &out->b, &out->c, &out->d, &out->e);
823 : }
824 :
825 : template<class ObjT, class Method, class InA,
826 : class OutA, class OutB, class OutC, class OutD, class OutE>
827 : inline void DispatchToMethod(ObjT* obj, Method method,
828 : const Tuple1<InA>& in,
829 : Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
830 : (obj->*method)(in.a, &out->a, &out->b, &out->c, &out->d, &out->e);
831 : }
832 :
833 : template<class ObjT, class Method, class InA, class InB,
834 : class OutA, class OutB, class OutC, class OutD, class OutE>
835 : inline void DispatchToMethod(ObjT* obj, Method method,
836 : const Tuple2<InA, InB>& in,
837 : Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
838 : (obj->*method)(in.a, in.b, &out->a, &out->b, &out->c, &out->d, &out->e);
839 : }
840 :
841 : template<class ObjT, class Method, class InA, class InB, class InC,
842 : class OutA, class OutB, class OutC, class OutD, class OutE>
843 : inline void DispatchToMethod(ObjT* obj, Method method,
844 : const Tuple3<InA, InB, InC>& in,
845 : Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
846 : (obj->*method)(in.a, in.b, in.c, &out->a, &out->b, &out->c, &out->d, &out->e);
847 : }
848 :
849 : template<class ObjT, class Method, class InA, class InB, class InC, class InD,
850 : class OutA, class OutB, class OutC, class OutD, class OutE>
851 : inline void DispatchToMethod(ObjT* obj, Method method,
852 : const Tuple4<InA, InB, InC, InD>& in,
853 : Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
854 : (obj->*method)(in.a, in.b, in.c, in.d, &out->a, &out->b, &out->c, &out->d,
855 : &out->e);
856 : }
857 :
858 : template<class ObjT, class Method,
859 : class InA, class InB, class InC, class InD, class InE,
860 : class OutA, class OutB, class OutC, class OutD, class OutE>
861 : inline void DispatchToMethod(ObjT* obj, Method method,
862 : const Tuple5<InA, InB, InC, InD, InE>& in,
863 : Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
864 : (obj->*method)(in.a, in.b, in.c, in.d, in.e,
865 : &out->a, &out->b, &out->c, &out->d, &out->e);
866 : }
867 :
868 : template<class ObjT, class Method,
869 : class InA, class InB, class InC, class InD, class InE, class InF,
870 : class OutA, class OutB, class OutC, class OutD, class OutE>
871 : inline void DispatchToMethod(ObjT* obj, Method method,
872 : const Tuple6<InA, InB, InC, InD, InE, InF>& in,
873 : Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
874 : (obj->*method)(in.a, in.b, in.c, in.d, in.e, in.f,
875 : &out->a, &out->b, &out->c, &out->d, &out->e);
876 : }
877 :
878 : #endif // BASE_TUPLE_H__
|