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