base/tuple.h

   1 // Copyright (c) 2011 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
  41 template <class P>
  42 struct TupleTraits {
  43   typedef P ValueType;
  44   typedef P& RefType;
  45   typedef const P& ParamType;
  46 };
  47
  48 template <class P>
  49 struct TupleTraits<P&> {
  50   typedef P ValueType;
  51   typedef P& RefType;
  52   typedef P& ParamType;
  53 };
  54
  55 template <class P>
  56 struct 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
  72 struct Tuple0 {
  73   typedef Tuple0 ValueTuple;
  74   typedef Tuple0 RefTuple;
  75   typedef Tuple0 ParamTuple;
  76 };
  77
  78 template <class A>
  79 struct 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
  89 template <class A, class B>
  90 struct 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
 105 template <class A, class B, class C>
 106 struct 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
 124 template <class A, class B, class C, class D>
 125 struct 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
 146 template <class A, class B, class C, class D, class E>
 147 struct 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
 171 template <class A, class B, class C, class D, class E, class F>
 172 struct 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
 199 template <class A, class B, class C, class D, class E, class F, class G>
 200 struct 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
 230 template <class A, class B, class C, class D, class E, class F, class G,
 231           class H>
 232 struct 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
 270 template <>
 271 struct TupleTypes< Tuple0 > {
 272   typedef Tuple0 ValueTuple;
 273   typedef Tuple0 RefTuple;
 274   typedef Tuple0 ParamTuple;
 275 };
 276
 277 template <class A>
 278 struct 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
 284 template <class A, class B>
 285 struct TupleTypes< Tuple2<A, B> > {
 286   typedef Tuple2<typename TupleTraits<A>::ValueType,
 287                  typename TupleTraits<B>::ValueType> ValueTuple;
 288 typedef 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
 294 template <class A, class B, class C>
 295 struct TupleTypes< Tuple3<A, B, C> > {
 296   typedef Tuple3<typename TupleTraits<A>::ValueType,
 297                  typename TupleTraits<B>::ValueType,
 298                  typename TupleTraits<C>::ValueType> ValueTuple;
 299 typedef 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
 307 template <class A, class B, class C, class D>
 308 struct 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;
 313 typedef 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
 323 template <class A, class B, class C, class D, class E>
 324 struct 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;
 330 typedef 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
 342 template <class A, class B, class C, class D, class E, class F>
 343 struct 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;
 350 typedef 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
 364 template <class A, class B, class C, class D, class E, class F, class G>
 365 struct 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;
 373 typedef 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
 389 template <class A, class B, class C, class D, class E, class F, class G,
 390           class H>
 391 struct 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;
 400 typedef 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
 423 inline Tuple0 MakeTuple() {
 424   return Tuple0();
 425 }
 426
 427 template <class A>
 428 inline Tuple1<A> MakeTuple(const A& a) {
 429   return Tuple1<A>(a);
 430 }
 431
 432 template <class A, class B>
 433 inline Tuple2<A, B> MakeTuple(const A& a, const B& b) {
 434   return Tuple2<A, B>(a, b);
 435 }
 436
 437 template <class A, class B, class C>
 438 inline 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
 442 template <class A, class B, class C, class D>
 443 inline 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
 448 template <class A, class B, class C, class D, class E>
 449 inline 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
 454 template <class A, class B, class C, class D, class E, class F>
 455 inline 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
 460 template <class A, class B, class C, class D, class E, class F, class G>
 461 inline 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
 467 template <class A, class B, class C, class D, class E, class F, class G,
 468           class H>
 469 inline 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
 479 template <class A>
 480 inline Tuple1<A&> MakeRefTuple(A& a) {
 481   return Tuple1<A&>(a);
 482 }
 483
 484 template <class A, class B>
 485 inline Tuple2<A&, B&> MakeRefTuple(A& a, B& b) {
 486   return Tuple2<A&, B&>(a, b);
 487 }
 488
 489 template <class A, class B, class C>
 490 inline Tuple3<A&, B&, C&> MakeRefTuple(A& a, B& b, C& c) {
 491   return Tuple3<A&, B&, C&>(a, b, c);
 492 }
 493
 494 template <class A, class B, class C, class D>
 495 inline 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
 499 template <class A, class B, class C, class D, class E>
 500 inline 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
 504 template <class A, class B, class C, class D, class E, class F>
 505 inline 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
 510 template <class A, class B, class C, class D, class E, class F, class G>
 511 inline 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
 516 template <class A, class B, class C, class D, class E, class F, class G,
 517           class H>
 518 inline 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
 535 template <class ObjT, class Method>
 536 inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& arg) {
 537   (obj->*method)();
 538 }
 539
 540 template <class ObjT, class Method, class A>
 541 inline void DispatchToMethod(ObjT* obj, Method method, const A& arg) {
 542   (obj->*method)(arg);
 543 }
 544
 545 template <class ObjT, class Method, class A>
 546 inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1<A>& arg) {
 547   (obj->*method)(arg.a);
 548 }
 549
 550 template<class ObjT, class Method, class A, class B>
 551 inline void DispatchToMethod(ObjT* obj,
 552                              Method method,
 553                              const Tuple2<A, B>& arg) {
 554   (obj->*method)(arg.a, arg.b);
 555 }
 556
 557 template<class ObjT, class Method, class A, class B, class C>
 558 inline void DispatchToMethod(ObjT* obj, Method method,
 559                              const Tuple3<A, B, C>& arg) {
 560   (obj->*method)(arg.a, arg.b, arg.c);
 561 }
 562
 563 template<class ObjT, class Method, class A, class B, class C, class D>
 564 inline 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
 569 template<class ObjT, class Method, class A, class B, class C, class D, class E>
 570 inline 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
 575 template<class ObjT, class Method, class A, class B, class C, class D, class E,
 576          class F>
 577 inline 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
 582 template<class ObjT, class Method, class A, class B, class C, class D, class E,
 583          class F, class G>
 584 inline 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
 589 template<class ObjT, class Method, class A, class B, class C, class D, class E,
 590          class F, class G, class H>
 591 inline 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
 596 // Static Dispatchers with no out params.
 597
 598 template <class Function>
 599 inline void DispatchToFunction(Function function, const Tuple0& arg) {
 600   (*function)();
 601 }
 602
 603 template <class Function, class A>
 604 inline void DispatchToFunction(Function function, const A& arg) {
 605   (*function)(arg);
 606 }
 607
 608 template <class Function, class A>
 609 inline void DispatchToFunction(Function function, const Tuple1<A>& arg) {
 610   (*function)(arg.a);
 611 }
 612
 613 template<class Function, class A, class B>
 614 inline void DispatchToFunction(Function function, const Tuple2<A, B>& arg) {
 615   (*function)(arg.a, arg.b);
 616 }
 617
 618 template<class Function, class A, class B, class C>
 619 inline void DispatchToFunction(Function function, const Tuple3<A, B, C>& arg) {
 620   (*function)(arg.a, arg.b, arg.c);
 621 }
 622
 623 template<class Function, class A, class B, class C, class D>
 624 inline void DispatchToFunction(Function function,
 625                                const Tuple4<A, B, C, D>& arg) {
 626   (*function)(arg.a, arg.b, arg.c, arg.d);
 627 }
 628
 629 template<class Function, class A, class B, class C, class D, class E>
 630 inline 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
 635 template<class Function, class A, class B, class C, class D, class E, class F>
 636 inline 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
 641 template<class Function, class A, class B, class C, class D, class E, class F,
 642          class G>
 643 inline 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
 648 template<class Function, class A, class B, class C, class D, class E, class F,
 649          class G, class H>
 650 inline 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
 657 template <class ObjT, class Method>
 658 inline void DispatchToMethod(ObjT* obj,
 659                              Method method,
 660                              const Tuple0& arg, Tuple0*) {
 661   (obj->*method)();
 662 }
 663
 664 template <class ObjT, class Method, class A>
 665 inline void DispatchToMethod(ObjT* obj, Method method, const A& arg, Tuple0*) {
 666   (obj->*method)(arg);
 667 }
 668
 669 template <class ObjT, class Method, class A>
 670 inline void DispatchToMethod(ObjT* obj,
 671                              Method method,
 672                              const Tuple1<A>& arg, Tuple0*) {
 673   (obj->*method)(arg.a);
 674 }
 675
 676 template<class ObjT, class Method, class A, class B>
 677 inline void DispatchToMethod(ObjT* obj,
 678                              Method method,
 679                              const Tuple2<A, B>& arg, Tuple0*) {
 680   (obj->*method)(arg.a, arg.b);
 681 }
 682
 683 template<class ObjT, class Method, class A, class B, class C>
 684 inline 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
 689 template<class ObjT, class Method, class A, class B, class C, class D>
 690 inline 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
 695 template<class ObjT, class Method, class A, class B, class C, class D, class E>
 696 inline 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
 701 template<class ObjT, class Method, class A, class B, class C, class D, class E,
 702          class F>
 703 inline 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
 710 template<class ObjT, class Method,
 711          class OutA>
 712 inline void DispatchToMethod(ObjT* obj, Method method,
 713                              const Tuple0& in,
 714                              Tuple1<OutA>* out) {
 715   (obj->*method)(&out->a);
 716 }
 717
 718 template<class ObjT, class Method, class InA,
 719          class OutA>
 720 inline void DispatchToMethod(ObjT* obj, Method method,
 721                              const InA& in,
 722                              Tuple1<OutA>* out) {
 723   (obj->*method)(in, &out->a);
 724 }
 725
 726 template<class ObjT, class Method, class InA,
 727          class OutA>
 728 inline void DispatchToMethod(ObjT* obj, Method method,
 729                              const Tuple1<InA>& in,
 730                              Tuple1<OutA>* out) {
 731   (obj->*method)(in.a, &out->a);
 732 }
 733
 734 template<class ObjT, class Method, class InA, class InB,
 735          class OutA>
 736 inline 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
 742 template<class ObjT, class Method, class InA, class InB, class InC,
 743          class OutA>
 744 inline 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
 750 template<class ObjT, class Method, class InA, class InB, class InC, class InD,
 751          class OutA>
 752 inline 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
 758 template<class ObjT, class Method, class InA, class InB, class InC, class InD,
 759          class InE, class OutA>
 760 inline 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
 766 template<class ObjT, class Method,
 767          class InA, class InB, class InC, class InD, class InE, class InF,
 768          class OutA>
 769 inline 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
 777 template<class ObjT, class Method,
 778          class OutA, class OutB>
 779 inline void DispatchToMethod(ObjT* obj, Method method,
 780                              const Tuple0& in,
 781                              Tuple2<OutA, OutB>* out) {
 782   (obj->*method)(&out->a, &out->b);
 783 }
 784
 785 template<class ObjT, class Method, class InA,
 786          class OutA, class OutB>
 787 inline 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
 793 template<class ObjT, class Method, class InA,
 794          class OutA, class OutB>
 795 inline 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
 801 template<class ObjT, class Method, class InA, class InB,
 802          class OutA, class OutB>
 803 inline 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
 809 template<class ObjT, class Method, class InA, class InB, class InC,
 810          class OutA, class OutB>
 811 inline 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
 817 template<class ObjT, class Method, class InA, class InB, class InC, class InD,
 818          class OutA, class OutB>
 819 inline 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
 825 template<class ObjT, class Method,
 826          class InA, class InB, class InC, class InD, class InE,
 827          class OutA, class OutB>
 828 inline 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
 834 template<class ObjT, class Method,
 835          class InA, class InB, class InC, class InD, class InE, class InF,
 836          class OutA, class OutB>
 837 inline 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
 845 template<class ObjT, class Method,
 846          class OutA, class OutB, class OutC>
 847 inline 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
 853 template<class ObjT, class Method, class InA,
 854          class OutA, class OutB, class OutC>
 855 inline 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
 861 template<class ObjT, class Method, class InA,
 862          class OutA, class OutB, class OutC>
 863 inline 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
 869 template<class ObjT, class Method, class InA, class InB,
 870          class OutA, class OutB, class OutC>
 871 inline 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
 877 template<class ObjT, class Method, class InA, class InB, class InC,
 878          class OutA, class OutB, class OutC>
 879 inline 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
 885 template<class ObjT, class Method, class InA, class InB, class InC, class InD,
 886          class OutA, class OutB, class OutC>
 887 inline 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
 893 template<class ObjT, class Method,
 894          class InA, class InB, class InC, class InD, class InE,
 895          class OutA, class OutB, class OutC>
 896 inline 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
 902 template<class ObjT, class Method,
 903          class InA, class InB, class InC, class InD, class InE, class InF,
 904          class OutA, class OutB, class OutC>
 905 inline 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
 913 template<class ObjT, class Method,
 914          class OutA, class OutB, class OutC, class OutD>
 915 inline 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
 921 template<class ObjT, class Method, class InA,
 922          class OutA, class OutB, class OutC, class OutD>
 923 inline 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
 929 template<class ObjT, class Method, class InA,
 930          class OutA, class OutB, class OutC, class OutD>
 931 inline 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
 937 template<class ObjT, class Method, class InA, class InB,
 938          class OutA, class OutB, class OutC, class OutD>
 939 inline 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
 945 template<class ObjT, class Method, class InA, class InB, class InC,
 946          class OutA, class OutB, class OutC, class OutD>
 947 inline 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
 953 template<class ObjT, class Method, class InA, class InB, class InC, class InD,
 954          class OutA, class OutB, class OutC, class OutD>
 955 inline 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
 961 template<class ObjT, class Method,
 962          class InA, class InB, class InC, class InD, class InE,
 963          class OutA, class OutB, class OutC, class OutD>
 964 inline 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
 971 template<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>
 974 inline 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
 983 template<class ObjT, class Method,
 984          class OutA, class OutB, class OutC, class OutD, class OutE>
 985 inline 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
 991 template<class ObjT, class Method, class InA,
 992          class OutA, class OutB, class OutC, class OutD, class OutE>
 993 inline 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
 999 template<class ObjT, class Method, class InA,
1000          class OutA, class OutB, class OutC, class OutD, class OutE>
1001 inline 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
1007 template<class ObjT, class Method, class InA, class InB,
1008          class OutA, class OutB, class OutC, class OutD, class OutE>
1009 inline 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
1015 template<class ObjT, class Method, class InA, class InB, class InC,
1016          class OutA, class OutB, class OutC, class OutD, class OutE>
1017 inline 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
1023 template<class ObjT, class Method, class InA, class InB, class InC, class InD,
1024          class OutA, class OutB, class OutC, class OutD, class OutE>
1025 inline 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
1032 template<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>
1035 inline 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
1042 template<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>
1045 inline 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__