LCOV - code coverage report
Current view: directory - ipc/chromium/src/base - tuple.h (source / functions) Found Hit Coverage
Test: app.info Lines: 32 2 6.2 %
Date: 2012-06-02 Functions: 63 1 1.6 %

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

Generated by: LCOV version 1.7