tuple.h revision 4a5e2dc747d50c653511c68ccb2cfbfb740bd5a7
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#pragma once 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 55template <class P> 56struct TupleTypes { }; 57 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// 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). 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; 75 typedef Tuple0 ParamTuple; 76}; 77 78template <class A> 79struct Tuple1 { 80 public: 81 typedef A TypeA; 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; 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; 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; 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 { 148 public: 149 typedef A TypeA; 150 typedef B TypeB; 151 typedef C TypeC; 152 typedef D TypeD; 153 typedef E TypeE; 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 171template <class A, class B, class C, class D, class E, class F> 172struct Tuple6 { 173 public: 174 typedef A TypeA; 175 typedef B TypeB; 176 typedef C TypeC; 177 typedef D TypeD; 178 typedef E TypeE; 179 typedef F TypeF; 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 199template <class A, class B, class C, class D, class E, class F, class G> 200struct Tuple7 { 201 public: 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; 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 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; 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 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 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 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 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 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 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 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 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 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 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 548#if defined(OS_CHROMEOS) && defined(CHECK) 549 // To troubleshoot crosbug.com/7327. 550 CHECK(obj); 551 CHECK(&arg); 552 CHECK(method); 553#endif 554 (obj->*method)(arg.a); 555} 556 557template<class ObjT, class Method, class A, class B> 558inline void DispatchToMethod(ObjT* obj, 559 Method method, 560 const Tuple2<A, B>& arg) { 561 (obj->*method)(arg.a, arg.b); 562} 563 564template<class ObjT, class Method, class A, class B, class C> 565inline void DispatchToMethod(ObjT* obj, Method method, 566 const Tuple3<A, B, C>& arg) { 567 (obj->*method)(arg.a, arg.b, arg.c); 568} 569 570template<class ObjT, class Method, class A, class B, class C, class D> 571inline void DispatchToMethod(ObjT* obj, Method method, 572 const Tuple4<A, B, C, D>& arg) { 573 (obj->*method)(arg.a, arg.b, arg.c, arg.d); 574} 575 576template<class ObjT, class Method, class A, class B, class C, class D, class E> 577inline void DispatchToMethod(ObjT* obj, Method method, 578 const Tuple5<A, B, C, D, E>& arg) { 579 (obj->*method)(arg.a, arg.b, arg.c, arg.d, arg.e); 580} 581 582template<class ObjT, class Method, class A, class B, class C, class D, class E, 583 class F> 584inline void DispatchToMethod(ObjT* obj, Method method, 585 const Tuple6<A, B, C, D, E, F>& arg) { 586 (obj->*method)(arg.a, arg.b, arg.c, arg.d, arg.e, arg.f); 587} 588 589template<class ObjT, class Method, class A, class B, class C, class D, class E, 590 class F, class G> 591inline void DispatchToMethod(ObjT* obj, Method method, 592 const Tuple7<A, B, C, D, E, F, G>& arg) { 593 (obj->*method)(arg.a, arg.b, arg.c, arg.d, arg.e, arg.f, arg.g); 594} 595 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 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 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 655// Dispatchers with 0 out param (as a Tuple0). 656 657template <class ObjT, class Method> 658inline void DispatchToMethod(ObjT* obj, 659 Method method, 660 const Tuple0& arg, Tuple0*) { 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> 670inline void DispatchToMethod(ObjT* obj, 671 Method method, 672 const Tuple1<A>& arg, Tuple0*) { 673 (obj->*method)(arg.a); 674} 675 676template<class ObjT, class Method, class A, class B> 677inline void DispatchToMethod(ObjT* obj, 678 Method method, 679 const Tuple2<A, B>& arg, Tuple0*) { 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 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 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 758template<class ObjT, class Method, class InA, class InB, class InC, class InD, 759 class InE, class OutA> 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 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 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 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 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 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 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 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 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 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 1052#endif // BASE_TUPLE_H__ 1053