The Tor Browser: media/mtransport/runnable_utils

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /* This Source Code Form is subject to the terms of the Mozilla Public

     2  * License, v. 2.0. If a copy of the MPL was not distributed with this

     3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     6 // 0 arguments --

     7 template<typename M> class runnable_args_nm_0 : public runnable_args_base {

     8  public:

     9   runnable_args_nm_0(M m) :

    10     m_(m)  {}

    12   NS_IMETHOD Run() {

    13     m_();

    14     return NS_OK;

    15   }

    17  private:

    18   M m_;

    19 };

    23 // 0 arguments --

    24 template<typename M, typename R> class runnable_args_nm_0_ret : public runnable_args_base {

    25  public:

    26   runnable_args_nm_0_ret(M m, R *r) :

    27     m_(m), r_(r)  {}

    28   virtual bool returns_value() const { return true; }

    30   NS_IMETHOD Run() {

    31     *r_ = m_();

    32     return NS_OK;

    33   }

    35  private:

    36   M m_;

    37   R* r_;

    38 };

    42 // 0 arguments --

    43 template<typename C, typename M> class runnable_args_m_0 : public runnable_args_base {

    44  public:

    45   runnable_args_m_0(C o, M m) :

    46     o_(o), m_(m)  {}

    48   NS_IMETHOD Run() {

    49     ((*o_).*m_)();

    50     return NS_OK;

    51   }

    53  private:

    54   C o_;

    55   M m_;

    56 };

    60 // 0 arguments --

    61 template<typename C, typename M, typename R> class runnable_args_m_0_ret : public runnable_args_base {

    62  public:

    63   runnable_args_m_0_ret(C o, M m, R *r) :

    64     o_(o), m_(m), r_(r)  {}

    65   virtual bool returns_value() const { return true; }

    67   NS_IMETHOD Run() {

    68     *r_ = ((*o_).*m_)();

    69     return NS_OK;

    70   }

    72  private:

    73   C o_;

    74   M m_;

    75   R* r_;

    76 };

    80 // 1 arguments --

    81 template<typename M, typename A0> class runnable_args_nm_1 : public runnable_args_base {

    82  public:

    83   runnable_args_nm_1(M m, A0 a0) :

    84     m_(m), a0_(a0)  {}

    86   NS_IMETHOD Run() {

    87     m_(a0_);

    88     return NS_OK;

    89   }

    91  private:

    92   M m_;

    93   A0 a0_;

    94 };

    98 // 1 arguments --

    99 template<typename M, typename A0, typename R> class runnable_args_nm_1_ret : public runnable_args_base {

   100  public:

   101   runnable_args_nm_1_ret(M m, A0 a0, R *r) :

   102     m_(m), r_(r), a0_(a0)  {}

   103   virtual bool returns_value() const { return true; }

   105   NS_IMETHOD Run() {

   106     *r_ = m_(a0_);

   107     return NS_OK;

   108   }

   110  private:

   111   M m_;

   112   R* r_;

   113   A0 a0_;

   114 };

   118 // 1 arguments --

   119 template<typename C, typename M, typename A0> class runnable_args_m_1 : public runnable_args_base {

   120  public:

   121   runnable_args_m_1(C o, M m, A0 a0) :

   122     o_(o), m_(m), a0_(a0)  {}

   124   NS_IMETHOD Run() {

   125     ((*o_).*m_)(a0_);

   126     return NS_OK;

   127   }

   129  private:

   130   C o_;

   131   M m_;

   132   A0 a0_;

   133 };

   137 // 1 arguments --

   138 template<typename C, typename M, typename A0, typename R> class runnable_args_m_1_ret : public runnable_args_base {

   139  public:

   140   runnable_args_m_1_ret(C o, M m, A0 a0, R *r) :

   141     o_(o), m_(m), r_(r), a0_(a0)  {}

   142   virtual bool returns_value() const { return true; }

   144   NS_IMETHOD Run() {

   145     *r_ = ((*o_).*m_)(a0_);

   146     return NS_OK;

   147   }

   149  private:

   150   C o_;

   151   M m_;

   152   R* r_;

   153   A0 a0_;

   154 };

   158 // 2 arguments --

   159 template<typename M, typename A0, typename A1> class runnable_args_nm_2 : public runnable_args_base {

   160  public:

   161   runnable_args_nm_2(M m, A0 a0, A1 a1) :

   162     m_(m), a0_(a0), a1_(a1)  {}

   164   NS_IMETHOD Run() {

   165     m_(a0_, a1_);

   166     return NS_OK;

   167   }

   169  private:

   170   M m_;

   171   A0 a0_;

   172   A1 a1_;

   173 };

   177 // 2 arguments --

   178 template<typename M, typename A0, typename A1, typename R> class runnable_args_nm_2_ret : public runnable_args_base {

   179  public:

   180   runnable_args_nm_2_ret(M m, A0 a0, A1 a1, R *r) :

   181     m_(m), r_(r), a0_(a0), a1_(a1)  {}

   182   virtual bool returns_value() const { return true; }

   184   NS_IMETHOD Run() {

   185     *r_ = m_(a0_, a1_);

   186     return NS_OK;

   187   }

   189  private:

   190   M m_;

   191   R* r_;

   192   A0 a0_;

   193   A1 a1_;

   194 };

   198 // 2 arguments --

   199 template<typename C, typename M, typename A0, typename A1> class runnable_args_m_2 : public runnable_args_base {

   200  public:

   201   runnable_args_m_2(C o, M m, A0 a0, A1 a1) :

   202     o_(o), m_(m), a0_(a0), a1_(a1)  {}

   204   NS_IMETHOD Run() {

   205     ((*o_).*m_)(a0_, a1_);

   206     return NS_OK;

   207   }

   209  private:

   210   C o_;

   211   M m_;

   212   A0 a0_;

   213   A1 a1_;

   214 };

   218 // 2 arguments --

   219 template<typename C, typename M, typename A0, typename A1, typename R> class runnable_args_m_2_ret : public runnable_args_base {

   220  public:

   221   runnable_args_m_2_ret(C o, M m, A0 a0, A1 a1, R *r) :

   222     o_(o), m_(m), r_(r), a0_(a0), a1_(a1)  {}

   223   virtual bool returns_value() const { return true; }

   225   NS_IMETHOD Run() {

   226     *r_ = ((*o_).*m_)(a0_, a1_);

   227     return NS_OK;

   228   }

   230  private:

   231   C o_;

   232   M m_;

   233   R* r_;

   234   A0 a0_;

   235   A1 a1_;

   236 };

   240 // 3 arguments --

   241 template<typename M, typename A0, typename A1, typename A2> class runnable_args_nm_3 : public runnable_args_base {

   242  public:

   243   runnable_args_nm_3(M m, A0 a0, A1 a1, A2 a2) :

   244     m_(m), a0_(a0), a1_(a1), a2_(a2)  {}

   246   NS_IMETHOD Run() {

   247     m_(a0_, a1_, a2_);

   248     return NS_OK;

   249   }

   251  private:

   252   M m_;

   253   A0 a0_;

   254   A1 a1_;

   255   A2 a2_;

   256 };

   260 // 3 arguments --

   261 template<typename M, typename A0, typename A1, typename A2, typename R> class runnable_args_nm_3_ret : public runnable_args_base {

   262  public:

   263   runnable_args_nm_3_ret(M m, A0 a0, A1 a1, A2 a2, R *r) :

   264     m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2)  {}

   265   virtual bool returns_value() const { return true; }

   267   NS_IMETHOD Run() {

   268     *r_ = m_(a0_, a1_, a2_);

   269     return NS_OK;

   270   }

   272  private:

   273   M m_;

   274   R* r_;

   275   A0 a0_;

   276   A1 a1_;

   277   A2 a2_;

   278 };

   282 // 3 arguments --

   283 template<typename C, typename M, typename A0, typename A1, typename A2> class runnable_args_m_3 : public runnable_args_base {

   284  public:

   285   runnable_args_m_3(C o, M m, A0 a0, A1 a1, A2 a2) :

   286     o_(o), m_(m), a0_(a0), a1_(a1), a2_(a2)  {}

   288   NS_IMETHOD Run() {

   289     ((*o_).*m_)(a0_, a1_, a2_);

   290     return NS_OK;

   291   }

   293  private:

   294   C o_;

   295   M m_;

   296   A0 a0_;

   297   A1 a1_;

   298   A2 a2_;

   299 };

   303 // 3 arguments --

   304 template<typename C, typename M, typename A0, typename A1, typename A2, typename R> class runnable_args_m_3_ret : public runnable_args_base {

   305  public:

   306   runnable_args_m_3_ret(C o, M m, A0 a0, A1 a1, A2 a2, R *r) :

   307     o_(o), m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2)  {}

   308   virtual bool returns_value() const { return true; }

   310   NS_IMETHOD Run() {

   311     *r_ = ((*o_).*m_)(a0_, a1_, a2_);

   312     return NS_OK;

   313   }

   315  private:

   316   C o_;

   317   M m_;

   318   R* r_;

   319   A0 a0_;

   320   A1 a1_;

   321   A2 a2_;

   322 };

   326 // 4 arguments --

   327 template<typename M, typename A0, typename A1, typename A2, typename A3> class runnable_args_nm_4 : public runnable_args_base {

   328  public:

   329   runnable_args_nm_4(M m, A0 a0, A1 a1, A2 a2, A3 a3) :

   330     m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3)  {}

   332   NS_IMETHOD Run() {

   333     m_(a0_, a1_, a2_, a3_);

   334     return NS_OK;

   335   }

   337  private:

   338   M m_;

   339   A0 a0_;

   340   A1 a1_;

   341   A2 a2_;

   342   A3 a3_;

   343 };

   347 // 4 arguments --

   348 template<typename M, typename A0, typename A1, typename A2, typename A3, typename R> class runnable_args_nm_4_ret : public runnable_args_base {

   349  public:

   350   runnable_args_nm_4_ret(M m, A0 a0, A1 a1, A2 a2, A3 a3, R *r) :

   351     m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3)  {}

   352   virtual bool returns_value() const { return true; }

   354   NS_IMETHOD Run() {

   355     *r_ = m_(a0_, a1_, a2_, a3_);

   356     return NS_OK;

   357   }

   359  private:

   360   M m_;

   361   R* r_;

   362   A0 a0_;

   363   A1 a1_;

   364   A2 a2_;

   365   A3 a3_;

   366 };

   370 // 4 arguments --

   371 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3> class runnable_args_m_4 : public runnable_args_base {

   372  public:

   373   runnable_args_m_4(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3) :

   374     o_(o), m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3)  {}

   376   NS_IMETHOD Run() {

   377     ((*o_).*m_)(a0_, a1_, a2_, a3_);

   378     return NS_OK;

   379   }

   381  private:

   382   C o_;

   383   M m_;

   384   A0 a0_;

   385   A1 a1_;

   386   A2 a2_;

   387   A3 a3_;

   388 };

   392 // 4 arguments --

   393 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename R> class runnable_args_m_4_ret : public runnable_args_base {

   394  public:

   395   runnable_args_m_4_ret(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, R *r) :

   396     o_(o), m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3)  {}

   397   virtual bool returns_value() const { return true; }

   399   NS_IMETHOD Run() {

   400     *r_ = ((*o_).*m_)(a0_, a1_, a2_, a3_);

   401     return NS_OK;

   402   }

   404  private:

   405   C o_;

   406   M m_;

   407   R* r_;

   408   A0 a0_;

   409   A1 a1_;

   410   A2 a2_;

   411   A3 a3_;

   412 };

   416 // 5 arguments --

   417 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4> class runnable_args_nm_5 : public runnable_args_base {

   418  public:

   419   runnable_args_nm_5(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) :

   420     m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4)  {}

   422   NS_IMETHOD Run() {

   423     m_(a0_, a1_, a2_, a3_, a4_);

   424     return NS_OK;

   425   }

   427  private:

   428   M m_;

   429   A0 a0_;

   430   A1 a1_;

   431   A2 a2_;

   432   A3 a3_;

   433   A4 a4_;

   434 };

   438 // 5 arguments --

   439 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename R> class runnable_args_nm_5_ret : public runnable_args_base {

   440  public:

   441   runnable_args_nm_5_ret(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, R *r) :

   442     m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4)  {}

   443   virtual bool returns_value() const { return true; }

   445   NS_IMETHOD Run() {

   446     *r_ = m_(a0_, a1_, a2_, a3_, a4_);

   447     return NS_OK;

   448   }

   450  private:

   451   M m_;

   452   R* r_;

   453   A0 a0_;

   454   A1 a1_;

   455   A2 a2_;

   456   A3 a3_;

   457   A4 a4_;

   458 };

   462 // 5 arguments --

   463 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4> class runnable_args_m_5 : public runnable_args_base {

   464  public:

   465   runnable_args_m_5(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) :

   466     o_(o), m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4)  {}

   468   NS_IMETHOD Run() {

   469     ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_);

   470     return NS_OK;

   471   }

   473  private:

   474   C o_;

   475   M m_;

   476   A0 a0_;

   477   A1 a1_;

   478   A2 a2_;

   479   A3 a3_;

   480   A4 a4_;

   481 };

   485 // 5 arguments --

   486 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename R> class runnable_args_m_5_ret : public runnable_args_base {

   487  public:

   488   runnable_args_m_5_ret(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, R *r) :

   489     o_(o), m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4)  {}

   490   virtual bool returns_value() const { return true; }

   492   NS_IMETHOD Run() {

   493     *r_ = ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_);

   494     return NS_OK;

   495   }

   497  private:

   498   C o_;

   499   M m_;

   500   R* r_;

   501   A0 a0_;

   502   A1 a1_;

   503   A2 a2_;

   504   A3 a3_;

   505   A4 a4_;

   506 };

   510 // 6 arguments --

   511 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> class runnable_args_nm_6 : public runnable_args_base {

   512  public:

   513   runnable_args_nm_6(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) :

   514     m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5)  {}

   516   NS_IMETHOD Run() {

   517     m_(a0_, a1_, a2_, a3_, a4_, a5_);

   518     return NS_OK;

   519   }

   521  private:

   522   M m_;

   523   A0 a0_;

   524   A1 a1_;

   525   A2 a2_;

   526   A3 a3_;

   527   A4 a4_;

   528   A5 a5_;

   529 };

   533 // 6 arguments --

   534 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename R> class runnable_args_nm_6_ret : public runnable_args_base {

   535  public:

   536   runnable_args_nm_6_ret(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, R *r) :

   537     m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5)  {}

   538   virtual bool returns_value() const { return true; }

   540   NS_IMETHOD Run() {

   541     *r_ = m_(a0_, a1_, a2_, a3_, a4_, a5_);

   542     return NS_OK;

   543   }

   545  private:

   546   M m_;

   547   R* r_;

   548   A0 a0_;

   549   A1 a1_;

   550   A2 a2_;

   551   A3 a3_;

   552   A4 a4_;

   553   A5 a5_;

   554 };

   558 // 6 arguments --

   559 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> class runnable_args_m_6 : public runnable_args_base {

   560  public:

   561   runnable_args_m_6(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) :

   562     o_(o), m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5)  {}

   564   NS_IMETHOD Run() {

   565     ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_, a5_);

   566     return NS_OK;

   567   }

   569  private:

   570   C o_;

   571   M m_;

   572   A0 a0_;

   573   A1 a1_;

   574   A2 a2_;

   575   A3 a3_;

   576   A4 a4_;

   577   A5 a5_;

   578 };

   582 // 6 arguments --

   583 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename R> class runnable_args_m_6_ret : public runnable_args_base {

   584  public:

   585   runnable_args_m_6_ret(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, R *r) :

   586     o_(o), m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5)  {}

   587   virtual bool returns_value() const { return true; }

   589   NS_IMETHOD Run() {

   590     *r_ = ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_, a5_);

   591     return NS_OK;

   592   }

   594  private:

   595   C o_;

   596   M m_;

   597   R* r_;

   598   A0 a0_;

   599   A1 a1_;

   600   A2 a2_;

   601   A3 a3_;

   602   A4 a4_;

   603   A5 a5_;

   604 };

   608 // 7 arguments --

   609 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> class runnable_args_nm_7 : public runnable_args_base {

   610  public:

   611   runnable_args_nm_7(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) :

   612     m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6)  {}

   614   NS_IMETHOD Run() {

   615     m_(a0_, a1_, a2_, a3_, a4_, a5_, a6_);

   616     return NS_OK;

   617   }

   619  private:

   620   M m_;

   621   A0 a0_;

   622   A1 a1_;

   623   A2 a2_;

   624   A3 a3_;

   625   A4 a4_;

   626   A5 a5_;

   627   A6 a6_;

   628 };

   632 // 7 arguments --

   633 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename R> class runnable_args_nm_7_ret : public runnable_args_base {

   634  public:

   635   runnable_args_nm_7_ret(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, R *r) :

   636     m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6)  {}

   637   virtual bool returns_value() const { return true; }

   639   NS_IMETHOD Run() {

   640     *r_ = m_(a0_, a1_, a2_, a3_, a4_, a5_, a6_);

   641     return NS_OK;

   642   }

   644  private:

   645   M m_;

   646   R* r_;

   647   A0 a0_;

   648   A1 a1_;

   649   A2 a2_;

   650   A3 a3_;

   651   A4 a4_;

   652   A5 a5_;

   653   A6 a6_;

   654 };

   658 // 7 arguments --

   659 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> class runnable_args_m_7 : public runnable_args_base {

   660  public:

   661   runnable_args_m_7(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) :

   662     o_(o), m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6)  {}

   664   NS_IMETHOD Run() {

   665     ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_, a5_, a6_);

   666     return NS_OK;

   667   }

   669  private:

   670   C o_;

   671   M m_;

   672   A0 a0_;

   673   A1 a1_;

   674   A2 a2_;

   675   A3 a3_;

   676   A4 a4_;

   677   A5 a5_;

   678   A6 a6_;

   679 };

   683 // 7 arguments --

   684 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename R> class runnable_args_m_7_ret : public runnable_args_base {

   685  public:

   686   runnable_args_m_7_ret(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, R *r) :

   687     o_(o), m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6)  {}

   688   virtual bool returns_value() const { return true; }

   690   NS_IMETHOD Run() {

   691     *r_ = ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_, a5_, a6_);

   692     return NS_OK;

   693   }

   695  private:

   696   C o_;

   697   M m_;

   698   R* r_;

   699   A0 a0_;

   700   A1 a1_;

   701   A2 a2_;

   702   A3 a3_;

   703   A4 a4_;

   704   A5 a5_;

   705   A6 a6_;

   706 };

   710 // 8 arguments --

   711 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> class runnable_args_nm_8 : public runnable_args_base {

   712  public:

   713   runnable_args_nm_8(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) :

   714     m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7)  {}

   716   NS_IMETHOD Run() {

   717     m_(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_);

   718     return NS_OK;

   719   }

   721  private:

   722   M m_;

   723   A0 a0_;

   724   A1 a1_;

   725   A2 a2_;

   726   A3 a3_;

   727   A4 a4_;

   728   A5 a5_;

   729   A6 a6_;

   730   A7 a7_;

   731 };

   735 // 8 arguments --

   736 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename R> class runnable_args_nm_8_ret : public runnable_args_base {

   737  public:

   738   runnable_args_nm_8_ret(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, R *r) :

   739     m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7)  {}

   740   virtual bool returns_value() const { return true; }

   742   NS_IMETHOD Run() {

   743     *r_ = m_(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_);

   744     return NS_OK;

   745   }

   747  private:

   748   M m_;

   749   R* r_;

   750   A0 a0_;

   751   A1 a1_;

   752   A2 a2_;

   753   A3 a3_;

   754   A4 a4_;

   755   A5 a5_;

   756   A6 a6_;

   757   A7 a7_;

   758 };

   762 // 8 arguments --

   763 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> class runnable_args_m_8 : public runnable_args_base {

   764  public:

   765   runnable_args_m_8(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) :

   766     o_(o), m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7)  {}

   768   NS_IMETHOD Run() {

   769     ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_);

   770     return NS_OK;

   771   }

   773  private:

   774   C o_;

   775   M m_;

   776   A0 a0_;

   777   A1 a1_;

   778   A2 a2_;

   779   A3 a3_;

   780   A4 a4_;

   781   A5 a5_;

   782   A6 a6_;

   783   A7 a7_;

   784 };

   788 // 8 arguments --

   789 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename R> class runnable_args_m_8_ret : public runnable_args_base {

   790  public:

   791   runnable_args_m_8_ret(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, R *r) :

   792     o_(o), m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7)  {}

   793   virtual bool returns_value() const { return true; }

   795   NS_IMETHOD Run() {

   796     *r_ = ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_);

   797     return NS_OK;

   798   }

   800  private:

   801   C o_;

   802   M m_;

   803   R* r_;

   804   A0 a0_;

   805   A1 a1_;

   806   A2 a2_;

   807   A3 a3_;

   808   A4 a4_;

   809   A5 a5_;

   810   A6 a6_;

   811   A7 a7_;

   812 };

   816 // 9 arguments --

   817 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> class runnable_args_nm_9 : public runnable_args_base {

   818  public:

   819   runnable_args_nm_9(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) :

   820     m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8)  {}

   822   NS_IMETHOD Run() {

   823     m_(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_);

   824     return NS_OK;

   825   }

   827  private:

   828   M m_;

   829   A0 a0_;

   830   A1 a1_;

   831   A2 a2_;

   832   A3 a3_;

   833   A4 a4_;

   834   A5 a5_;

   835   A6 a6_;

   836   A7 a7_;

   837   A8 a8_;

   838 };

   842 // 9 arguments --

   843 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename R> class runnable_args_nm_9_ret : public runnable_args_base {

   844  public:

   845   runnable_args_nm_9_ret(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, R *r) :

   846     m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8)  {}

   847   virtual bool returns_value() const { return true; }

   849   NS_IMETHOD Run() {

   850     *r_ = m_(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_);

   851     return NS_OK;

   852   }

   854  private:

   855   M m_;

   856   R* r_;

   857   A0 a0_;

   858   A1 a1_;

   859   A2 a2_;

   860   A3 a3_;

   861   A4 a4_;

   862   A5 a5_;

   863   A6 a6_;

   864   A7 a7_;

   865   A8 a8_;

   866 };

   870 // 9 arguments --

   871 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> class runnable_args_m_9 : public runnable_args_base {

   872  public:

   873   runnable_args_m_9(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) :

   874     o_(o), m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8)  {}

   876   NS_IMETHOD Run() {

   877     ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_);

   878     return NS_OK;

   879   }

   881  private:

   882   C o_;

   883   M m_;

   884   A0 a0_;

   885   A1 a1_;

   886   A2 a2_;

   887   A3 a3_;

   888   A4 a4_;

   889   A5 a5_;

   890   A6 a6_;

   891   A7 a7_;

   892   A8 a8_;

   893 };

   897 // 9 arguments --

   898 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename R> class runnable_args_m_9_ret : public runnable_args_base {

   899  public:

   900   runnable_args_m_9_ret(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, R *r) :

   901     o_(o), m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8)  {}

   902   virtual bool returns_value() const { return true; }

   904   NS_IMETHOD Run() {

   905     *r_ = ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_);

   906     return NS_OK;

   907   }

   909  private:

   910   C o_;

   911   M m_;

   912   R* r_;

   913   A0 a0_;

   914   A1 a1_;

   915   A2 a2_;

   916   A3 a3_;

   917   A4 a4_;

   918   A5 a5_;

   919   A6 a6_;

   920   A7 a7_;

   921   A8 a8_;

   922 };

   926 // 10 arguments --

   927 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> class runnable_args_nm_10 : public runnable_args_base {

   928  public:

   929   runnable_args_nm_10(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) :

   930     m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9)  {}

   932   NS_IMETHOD Run() {

   933     m_(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_);

   934     return NS_OK;

   935   }

   937  private:

   938   M m_;

   939   A0 a0_;

   940   A1 a1_;

   941   A2 a2_;

   942   A3 a3_;

   943   A4 a4_;

   944   A5 a5_;

   945   A6 a6_;

   946   A7 a7_;

   947   A8 a8_;

   948   A9 a9_;

   949 };

   953 // 10 arguments --

   954 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename R> class runnable_args_nm_10_ret : public runnable_args_base {

   955  public:

   956   runnable_args_nm_10_ret(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, R *r) :

   957     m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9)  {}

   958   virtual bool returns_value() const { return true; }

   960   NS_IMETHOD Run() {

   961     *r_ = m_(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_);

   962     return NS_OK;

   963   }

   965  private:

   966   M m_;

   967   R* r_;

   968   A0 a0_;

   969   A1 a1_;

   970   A2 a2_;

   971   A3 a3_;

   972   A4 a4_;

   973   A5 a5_;

   974   A6 a6_;

   975   A7 a7_;

   976   A8 a8_;

   977   A9 a9_;

   978 };

   982 // 10 arguments --

   983 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> class runnable_args_m_10 : public runnable_args_base {

   984  public:

   985   runnable_args_m_10(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) :

   986     o_(o), m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9)  {}

   988   NS_IMETHOD Run() {

   989     ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_);

   990     return NS_OK;

   991   }

   993  private:

   994   C o_;

   995   M m_;

   996   A0 a0_;

   997   A1 a1_;

   998   A2 a2_;

   999   A3 a3_;

  1000   A4 a4_;

  1001   A5 a5_;

  1002   A6 a6_;

  1003   A7 a7_;

  1004   A8 a8_;

  1005   A9 a9_;

  1006 };

  1010 // 10 arguments --

  1011 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename R> class runnable_args_m_10_ret : public runnable_args_base {

  1012  public:

  1013   runnable_args_m_10_ret(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, R *r) :

  1014     o_(o), m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9)  {}

  1015   virtual bool returns_value() const { return true; }

  1017   NS_IMETHOD Run() {

  1018     *r_ = ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_);

  1019     return NS_OK;

  1020   }

  1022  private:

  1023   C o_;

  1024   M m_;

  1025   R* r_;

  1026   A0 a0_;

  1027   A1 a1_;

  1028   A2 a2_;

  1029   A3 a3_;

  1030   A4 a4_;

  1031   A5 a5_;

  1032   A6 a6_;

  1033   A7 a7_;

  1034   A8 a8_;

  1035   A9 a9_;

  1036 };

  1040 // 11 arguments --

  1041 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> class runnable_args_nm_11 : public runnable_args_base {

  1042  public:

  1043   runnable_args_nm_11(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) :

  1044     m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9), a10_(a10)  {}

  1046   NS_IMETHOD Run() {

  1047     m_(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_, a10_);

  1048     return NS_OK;

  1049   }

  1051  private:

  1052   M m_;

  1053   A0 a0_;

  1054   A1 a1_;

  1055   A2 a2_;

  1056   A3 a3_;

  1057   A4 a4_;

  1058   A5 a5_;

  1059   A6 a6_;

  1060   A7 a7_;

  1061   A8 a8_;

  1062   A9 a9_;

  1063   A10 a10_;

  1064 };

  1068 // 11 arguments --

  1069 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename R> class runnable_args_nm_11_ret : public runnable_args_base {

  1070  public:

  1071   runnable_args_nm_11_ret(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, R *r) :

  1072     m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9), a10_(a10)  {}

  1073   virtual bool returns_value() const { return true; }

  1075   NS_IMETHOD Run() {

  1076     *r_ = m_(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_, a10_);

  1077     return NS_OK;

  1078   }

  1080  private:

  1081   M m_;

  1082   R* r_;

  1083   A0 a0_;

  1084   A1 a1_;

  1085   A2 a2_;

  1086   A3 a3_;

  1087   A4 a4_;

  1088   A5 a5_;

  1089   A6 a6_;

  1090   A7 a7_;

  1091   A8 a8_;

  1092   A9 a9_;

  1093   A10 a10_;

  1094 };

  1098 // 11 arguments --

  1099 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> class runnable_args_m_11 : public runnable_args_base {

  1100  public:

  1101   runnable_args_m_11(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) :

  1102     o_(o), m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9), a10_(a10)  {}

  1104   NS_IMETHOD Run() {

  1105     ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_, a10_);

  1106     return NS_OK;

  1107   }

  1109  private:

  1110   C o_;

  1111   M m_;

  1112   A0 a0_;

  1113   A1 a1_;

  1114   A2 a2_;

  1115   A3 a3_;

  1116   A4 a4_;

  1117   A5 a5_;

  1118   A6 a6_;

  1119   A7 a7_;

  1120   A8 a8_;

  1121   A9 a9_;

  1122   A10 a10_;

  1123 };

  1127 // 11 arguments --

  1128 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename R> class runnable_args_m_11_ret : public runnable_args_base {

  1129  public:

  1130   runnable_args_m_11_ret(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, R *r) :

  1131     o_(o), m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9), a10_(a10)  {}

  1132   virtual bool returns_value() const { return true; }

  1134   NS_IMETHOD Run() {

  1135     *r_ = ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_, a10_);

  1136     return NS_OK;

  1137   }

  1139  private:

  1140   C o_;

  1141   M m_;

  1142   R* r_;

  1143   A0 a0_;

  1144   A1 a1_;

  1145   A2 a2_;

  1146   A3 a3_;

  1147   A4 a4_;

  1148   A5 a5_;

  1149   A6 a6_;

  1150   A7 a7_;

  1151   A8 a8_;

  1152   A9 a9_;

  1153   A10 a10_;

  1154 };

  1158 // 12 arguments --

  1159 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> class runnable_args_nm_12 : public runnable_args_base {

  1160  public:

  1161   runnable_args_nm_12(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) :

  1162     m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9), a10_(a10), a11_(a11)  {}

  1164   NS_IMETHOD Run() {

  1165     m_(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_, a10_, a11_);

  1166     return NS_OK;

  1167   }

  1169  private:

  1170   M m_;

  1171   A0 a0_;

  1172   A1 a1_;

  1173   A2 a2_;

  1174   A3 a3_;

  1175   A4 a4_;

  1176   A5 a5_;

  1177   A6 a6_;

  1178   A7 a7_;

  1179   A8 a8_;

  1180   A9 a9_;

  1181   A10 a10_;

  1182   A11 a11_;

  1183 };

  1187 // 12 arguments --

  1188 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename R> class runnable_args_nm_12_ret : public runnable_args_base {

  1189  public:

  1190   runnable_args_nm_12_ret(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, R *r) :

  1191     m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9), a10_(a10), a11_(a11)  {}

  1192   virtual bool returns_value() const { return true; }

  1194   NS_IMETHOD Run() {

  1195     *r_ = m_(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_, a10_, a11_);

  1196     return NS_OK;

  1197   }

  1199  private:

  1200   M m_;

  1201   R* r_;

  1202   A0 a0_;

  1203   A1 a1_;

  1204   A2 a2_;

  1205   A3 a3_;

  1206   A4 a4_;

  1207   A5 a5_;

  1208   A6 a6_;

  1209   A7 a7_;

  1210   A8 a8_;

  1211   A9 a9_;

  1212   A10 a10_;

  1213   A11 a11_;

  1214 };

  1218 // 12 arguments --

  1219 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> class runnable_args_m_12 : public runnable_args_base {

  1220  public:

  1221   runnable_args_m_12(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) :

  1222     o_(o), m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9), a10_(a10), a11_(a11)  {}

  1224   NS_IMETHOD Run() {

  1225     ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_, a10_, a11_);

  1226     return NS_OK;

  1227   }

  1229  private:

  1230   C o_;

  1231   M m_;

  1232   A0 a0_;

  1233   A1 a1_;

  1234   A2 a2_;

  1235   A3 a3_;

  1236   A4 a4_;

  1237   A5 a5_;

  1238   A6 a6_;

  1239   A7 a7_;

  1240   A8 a8_;

  1241   A9 a9_;

  1242   A10 a10_;

  1243   A11 a11_;

  1244 };

  1248 // 12 arguments --

  1249 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename R> class runnable_args_m_12_ret : public runnable_args_base {

  1250  public:

  1251   runnable_args_m_12_ret(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, R *r) :

  1252     o_(o), m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9), a10_(a10), a11_(a11)  {}

  1253   virtual bool returns_value() const { return true; }

  1255   NS_IMETHOD Run() {

  1256     *r_ = ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_, a10_, a11_);

  1257     return NS_OK;

  1258   }

  1260  private:

  1261   C o_;

  1262   M m_;

  1263   R* r_;

  1264   A0 a0_;

  1265   A1 a1_;

  1266   A2 a2_;

  1267   A3 a3_;

  1268   A4 a4_;

  1269   A5 a5_;

  1270   A6 a6_;

  1271   A7 a7_;

  1272   A8 a8_;

  1273   A9 a9_;

  1274   A10 a10_;

  1275   A11 a11_;

  1276 };

  1280 // 13 arguments --

  1281 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> class runnable_args_nm_13 : public runnable_args_base {

  1282  public:

  1283   runnable_args_nm_13(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) :

  1284     m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9), a10_(a10), a11_(a11), a12_(a12)  {}

  1286   NS_IMETHOD Run() {

  1287     m_(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_, a10_, a11_, a12_);

  1288     return NS_OK;

  1289   }

  1291  private:

  1292   M m_;

  1293   A0 a0_;

  1294   A1 a1_;

  1295   A2 a2_;

  1296   A3 a3_;

  1297   A4 a4_;

  1298   A5 a5_;

  1299   A6 a6_;

  1300   A7 a7_;

  1301   A8 a8_;

  1302   A9 a9_;

  1303   A10 a10_;

  1304   A11 a11_;

  1305   A12 a12_;

  1306 };

  1310 // 13 arguments --

  1311 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename R> class runnable_args_nm_13_ret : public runnable_args_base {

  1312  public:

  1313   runnable_args_nm_13_ret(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, R *r) :

  1314     m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9), a10_(a10), a11_(a11), a12_(a12)  {}

  1315   virtual bool returns_value() const { return true; }

  1317   NS_IMETHOD Run() {

  1318     *r_ = m_(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_, a10_, a11_, a12_);

  1319     return NS_OK;

  1320   }

  1322  private:

  1323   M m_;

  1324   R* r_;

  1325   A0 a0_;

  1326   A1 a1_;

  1327   A2 a2_;

  1328   A3 a3_;

  1329   A4 a4_;

  1330   A5 a5_;

  1331   A6 a6_;

  1332   A7 a7_;

  1333   A8 a8_;

  1334   A9 a9_;

  1335   A10 a10_;

  1336   A11 a11_;

  1337   A12 a12_;

  1338 };

  1342 // 13 arguments --

  1343 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> class runnable_args_m_13 : public runnable_args_base {

  1344  public:

  1345   runnable_args_m_13(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) :

  1346     o_(o), m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9), a10_(a10), a11_(a11), a12_(a12)  {}

  1348   NS_IMETHOD Run() {

  1349     ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_, a10_, a11_, a12_);

  1350     return NS_OK;

  1351   }

  1353  private:

  1354   C o_;

  1355   M m_;

  1356   A0 a0_;

  1357   A1 a1_;

  1358   A2 a2_;

  1359   A3 a3_;

  1360   A4 a4_;

  1361   A5 a5_;

  1362   A6 a6_;

  1363   A7 a7_;

  1364   A8 a8_;

  1365   A9 a9_;

  1366   A10 a10_;

  1367   A11 a11_;

  1368   A12 a12_;

  1369 };

  1373 // 13 arguments --

  1374 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename R> class runnable_args_m_13_ret : public runnable_args_base {

  1375  public:

  1376   runnable_args_m_13_ret(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, R *r) :

  1377     o_(o), m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9), a10_(a10), a11_(a11), a12_(a12)  {}

  1378   virtual bool returns_value() const { return true; }

  1380   NS_IMETHOD Run() {

  1381     *r_ = ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_, a10_, a11_, a12_);

  1382     return NS_OK;

  1383   }

  1385  private:

  1386   C o_;

  1387   M m_;

  1388   R* r_;

  1389   A0 a0_;

  1390   A1 a1_;

  1391   A2 a2_;

  1392   A3 a3_;

  1393   A4 a4_;

  1394   A5 a5_;

  1395   A6 a6_;

  1396   A7 a7_;

  1397   A8 a8_;

  1398   A9 a9_;

  1399   A10 a10_;

  1400   A11 a11_;

  1401   A12 a12_;

  1402 };

  1406 // 14 arguments --

  1407 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> class runnable_args_nm_14 : public runnable_args_base {

  1408  public:

  1409   runnable_args_nm_14(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) :

  1410     m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9), a10_(a10), a11_(a11), a12_(a12), a13_(a13)  {}

  1412   NS_IMETHOD Run() {

  1413     m_(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_, a10_, a11_, a12_, a13_);

  1414     return NS_OK;

  1415   }

  1417  private:

  1418   M m_;

  1419   A0 a0_;

  1420   A1 a1_;

  1421   A2 a2_;

  1422   A3 a3_;

  1423   A4 a4_;

  1424   A5 a5_;

  1425   A6 a6_;

  1426   A7 a7_;

  1427   A8 a8_;

  1428   A9 a9_;

  1429   A10 a10_;

  1430   A11 a11_;

  1431   A12 a12_;

  1432   A13 a13_;

  1433 };

  1437 // 14 arguments --

  1438 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename R> class runnable_args_nm_14_ret : public runnable_args_base {

  1439  public:

  1440   runnable_args_nm_14_ret(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, R *r) :

  1441     m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9), a10_(a10), a11_(a11), a12_(a12), a13_(a13)  {}

  1442   virtual bool returns_value() const { return true; }

  1444   NS_IMETHOD Run() {

  1445     *r_ = m_(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_, a10_, a11_, a12_, a13_);

  1446     return NS_OK;

  1447   }

  1449  private:

  1450   M m_;

  1451   R* r_;

  1452   A0 a0_;

  1453   A1 a1_;

  1454   A2 a2_;

  1455   A3 a3_;

  1456   A4 a4_;

  1457   A5 a5_;

  1458   A6 a6_;

  1459   A7 a7_;

  1460   A8 a8_;

  1461   A9 a9_;

  1462   A10 a10_;

  1463   A11 a11_;

  1464   A12 a12_;

  1465   A13 a13_;

  1466 };

  1470 // 14 arguments --

  1471 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> class runnable_args_m_14 : public runnable_args_base {

  1472  public:

  1473   runnable_args_m_14(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) :

  1474     o_(o), m_(m), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9), a10_(a10), a11_(a11), a12_(a12), a13_(a13)  {}

  1476   NS_IMETHOD Run() {

  1477     ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_, a10_, a11_, a12_, a13_);

  1478     return NS_OK;

  1479   }

  1481  private:

  1482   C o_;

  1483   M m_;

  1484   A0 a0_;

  1485   A1 a1_;

  1486   A2 a2_;

  1487   A3 a3_;

  1488   A4 a4_;

  1489   A5 a5_;

  1490   A6 a6_;

  1491   A7 a7_;

  1492   A8 a8_;

  1493   A9 a9_;

  1494   A10 a10_;

  1495   A11 a11_;

  1496   A12 a12_;

  1497   A13 a13_;

  1498 };

  1502 // 14 arguments --

  1503 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename R> class runnable_args_m_14_ret : public runnable_args_base {

  1504  public:

  1505   runnable_args_m_14_ret(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, R *r) :

  1506     o_(o), m_(m), r_(r), a0_(a0), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9), a10_(a10), a11_(a11), a12_(a12), a13_(a13)  {}

  1507   virtual bool returns_value() const { return true; }

  1509   NS_IMETHOD Run() {

  1510     *r_ = ((*o_).*m_)(a0_, a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_, a10_, a11_, a12_, a13_);

  1511     return NS_OK;

  1512   }

  1514  private:

  1515   C o_;

  1516   M m_;

  1517   R* r_;

  1518   A0 a0_;

  1519   A1 a1_;

  1520   A2 a2_;

  1521   A3 a3_;

  1522   A4 a4_;

  1523   A5 a5_;

  1524   A6 a6_;

  1525   A7 a7_;

  1526   A8 a8_;

  1527   A9 a9_;

  1528   A10 a10_;

  1529   A11 a11_;

  1530   A12 a12_;

  1531   A13 a13_;

  1532 };

  1539 // 0 arguments --

  1540 template<typename M>

  1541 runnable_args_nm_0<M>* WrapRunnableNM(M m) {

  1542   return new runnable_args_nm_0<M>

  1543     (m);

  1544 }

  1546 // 0 arguments --

  1547 template<typename M, typename R>

  1548 runnable_args_nm_0_ret<M, R>* WrapRunnableNMRet(M m, R* r) {

  1549   return new runnable_args_nm_0_ret<M, R>

  1550     (m, r);

  1551 }

  1553 // 0 arguments --

  1554 template<typename C, typename M>

  1555 runnable_args_m_0<C, M>* WrapRunnable(C o, M m) {

  1556   return new runnable_args_m_0<C, M>

  1557     (o, m);

  1558 }

  1560 // 0 arguments --

  1561 template<typename C, typename M, typename R>

  1562 runnable_args_m_0_ret<C, M, R>* WrapRunnableRet(C o, M m, R* r) {

  1563   return new runnable_args_m_0_ret<C, M, R>

  1564     (o, m, r);

  1565 }

  1567 // 1 arguments --

  1568 template<typename M, typename A0>

  1569 runnable_args_nm_1<M, A0>* WrapRunnableNM(M m, A0 a0) {

  1570   return new runnable_args_nm_1<M, A0>

  1571     (m, a0);

  1572 }

  1574 // 1 arguments --

  1575 template<typename M, typename A0, typename R>

  1576 runnable_args_nm_1_ret<M, A0, R>* WrapRunnableNMRet(M m, A0 a0, R* r) {

  1577   return new runnable_args_nm_1_ret<M, A0, R>

  1578     (m, a0, r);

  1579 }

  1581 // 1 arguments --

  1582 template<typename C, typename M, typename A0>

  1583 runnable_args_m_1<C, M, A0>* WrapRunnable(C o, M m, A0 a0) {

  1584   return new runnable_args_m_1<C, M, A0>

  1585     (o, m, a0);

  1586 }

  1588 // 1 arguments --

  1589 template<typename C, typename M, typename A0, typename R>

  1590 runnable_args_m_1_ret<C, M, A0, R>* WrapRunnableRet(C o, M m, A0 a0, R* r) {

  1591   return new runnable_args_m_1_ret<C, M, A0, R>

  1592     (o, m, a0, r);

  1593 }

  1595 // 2 arguments --

  1596 template<typename M, typename A0, typename A1>

  1597 runnable_args_nm_2<M, A0, A1>* WrapRunnableNM(M m, A0 a0, A1 a1) {

  1598   return new runnable_args_nm_2<M, A0, A1>

  1599     (m, a0, a1);

  1600 }

  1602 // 2 arguments --

  1603 template<typename M, typename A0, typename A1, typename R>

  1604 runnable_args_nm_2_ret<M, A0, A1, R>* WrapRunnableNMRet(M m, A0 a0, A1 a1, R* r) {

  1605   return new runnable_args_nm_2_ret<M, A0, A1, R>

  1606     (m, a0, a1, r);

  1607 }

  1609 // 2 arguments --

  1610 template<typename C, typename M, typename A0, typename A1>

  1611 runnable_args_m_2<C, M, A0, A1>* WrapRunnable(C o, M m, A0 a0, A1 a1) {

  1612   return new runnable_args_m_2<C, M, A0, A1>

  1613     (o, m, a0, a1);

  1614 }

  1616 // 2 arguments --

  1617 template<typename C, typename M, typename A0, typename A1, typename R>

  1618 runnable_args_m_2_ret<C, M, A0, A1, R>* WrapRunnableRet(C o, M m, A0 a0, A1 a1, R* r) {

  1619   return new runnable_args_m_2_ret<C, M, A0, A1, R>

  1620     (o, m, a0, a1, r);

  1621 }

  1623 // 3 arguments --

  1624 template<typename M, typename A0, typename A1, typename A2>

  1625 runnable_args_nm_3<M, A0, A1, A2>* WrapRunnableNM(M m, A0 a0, A1 a1, A2 a2) {

  1626   return new runnable_args_nm_3<M, A0, A1, A2>

  1627     (m, a0, a1, a2);

  1628 }

  1630 // 3 arguments --

  1631 template<typename M, typename A0, typename A1, typename A2, typename R>

  1632 runnable_args_nm_3_ret<M, A0, A1, A2, R>* WrapRunnableNMRet(M m, A0 a0, A1 a1, A2 a2, R* r) {

  1633   return new runnable_args_nm_3_ret<M, A0, A1, A2, R>

  1634     (m, a0, a1, a2, r);

  1635 }

  1637 // 3 arguments --

  1638 template<typename C, typename M, typename A0, typename A1, typename A2>

  1639 runnable_args_m_3<C, M, A0, A1, A2>* WrapRunnable(C o, M m, A0 a0, A1 a1, A2 a2) {

  1640   return new runnable_args_m_3<C, M, A0, A1, A2>

  1641     (o, m, a0, a1, a2);

  1642 }

  1644 // 3 arguments --

  1645 template<typename C, typename M, typename A0, typename A1, typename A2, typename R>

  1646 runnable_args_m_3_ret<C, M, A0, A1, A2, R>* WrapRunnableRet(C o, M m, A0 a0, A1 a1, A2 a2, R* r) {

  1647   return new runnable_args_m_3_ret<C, M, A0, A1, A2, R>

  1648     (o, m, a0, a1, a2, r);

  1649 }

  1651 // 4 arguments --

  1652 template<typename M, typename A0, typename A1, typename A2, typename A3>

  1653 runnable_args_nm_4<M, A0, A1, A2, A3>* WrapRunnableNM(M m, A0 a0, A1 a1, A2 a2, A3 a3) {

  1654   return new runnable_args_nm_4<M, A0, A1, A2, A3>

  1655     (m, a0, a1, a2, a3);

  1656 }

  1658 // 4 arguments --

  1659 template<typename M, typename A0, typename A1, typename A2, typename A3, typename R>

  1660 runnable_args_nm_4_ret<M, A0, A1, A2, A3, R>* WrapRunnableNMRet(M m, A0 a0, A1 a1, A2 a2, A3 a3, R* r) {

  1661   return new runnable_args_nm_4_ret<M, A0, A1, A2, A3, R>

  1662     (m, a0, a1, a2, a3, r);

  1663 }

  1665 // 4 arguments --

  1666 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3>

  1667 runnable_args_m_4<C, M, A0, A1, A2, A3>* WrapRunnable(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3) {

  1668   return new runnable_args_m_4<C, M, A0, A1, A2, A3>

  1669     (o, m, a0, a1, a2, a3);

  1670 }

  1672 // 4 arguments --

  1673 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename R>

  1674 runnable_args_m_4_ret<C, M, A0, A1, A2, A3, R>* WrapRunnableRet(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, R* r) {

  1675   return new runnable_args_m_4_ret<C, M, A0, A1, A2, A3, R>

  1676     (o, m, a0, a1, a2, a3, r);

  1677 }

  1679 // 5 arguments --

  1680 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4>

  1681 runnable_args_nm_5<M, A0, A1, A2, A3, A4>* WrapRunnableNM(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {

  1682   return new runnable_args_nm_5<M, A0, A1, A2, A3, A4>

  1683     (m, a0, a1, a2, a3, a4);

  1684 }

  1686 // 5 arguments --

  1687 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename R>

  1688 runnable_args_nm_5_ret<M, A0, A1, A2, A3, A4, R>* WrapRunnableNMRet(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, R* r) {

  1689   return new runnable_args_nm_5_ret<M, A0, A1, A2, A3, A4, R>

  1690     (m, a0, a1, a2, a3, a4, r);

  1691 }

  1693 // 5 arguments --

  1694 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4>

  1695 runnable_args_m_5<C, M, A0, A1, A2, A3, A4>* WrapRunnable(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {

  1696   return new runnable_args_m_5<C, M, A0, A1, A2, A3, A4>

  1697     (o, m, a0, a1, a2, a3, a4);

  1698 }

  1700 // 5 arguments --

  1701 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename R>

  1702 runnable_args_m_5_ret<C, M, A0, A1, A2, A3, A4, R>* WrapRunnableRet(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, R* r) {

  1703   return new runnable_args_m_5_ret<C, M, A0, A1, A2, A3, A4, R>

  1704     (o, m, a0, a1, a2, a3, a4, r);

  1705 }

  1707 // 6 arguments --

  1708 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>

  1709 runnable_args_nm_6<M, A0, A1, A2, A3, A4, A5>* WrapRunnableNM(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {

  1710   return new runnable_args_nm_6<M, A0, A1, A2, A3, A4, A5>

  1711     (m, a0, a1, a2, a3, a4, a5);

  1712 }

  1714 // 6 arguments --

  1715 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename R>

  1716 runnable_args_nm_6_ret<M, A0, A1, A2, A3, A4, A5, R>* WrapRunnableNMRet(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, R* r) {

  1717   return new runnable_args_nm_6_ret<M, A0, A1, A2, A3, A4, A5, R>

  1718     (m, a0, a1, a2, a3, a4, a5, r);

  1719 }

  1721 // 6 arguments --

  1722 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>

  1723 runnable_args_m_6<C, M, A0, A1, A2, A3, A4, A5>* WrapRunnable(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {

  1724   return new runnable_args_m_6<C, M, A0, A1, A2, A3, A4, A5>

  1725     (o, m, a0, a1, a2, a3, a4, a5);

  1726 }

  1728 // 6 arguments --

  1729 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename R>

  1730 runnable_args_m_6_ret<C, M, A0, A1, A2, A3, A4, A5, R>* WrapRunnableRet(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, R* r) {

  1731   return new runnable_args_m_6_ret<C, M, A0, A1, A2, A3, A4, A5, R>

  1732     (o, m, a0, a1, a2, a3, a4, a5, r);

  1733 }

  1735 // 7 arguments --

  1736 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>

  1737 runnable_args_nm_7<M, A0, A1, A2, A3, A4, A5, A6>* WrapRunnableNM(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {

  1738   return new runnable_args_nm_7<M, A0, A1, A2, A3, A4, A5, A6>

  1739     (m, a0, a1, a2, a3, a4, a5, a6);

  1740 }

  1742 // 7 arguments --

  1743 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename R>

  1744 runnable_args_nm_7_ret<M, A0, A1, A2, A3, A4, A5, A6, R>* WrapRunnableNMRet(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, R* r) {

  1745   return new runnable_args_nm_7_ret<M, A0, A1, A2, A3, A4, A5, A6, R>

  1746     (m, a0, a1, a2, a3, a4, a5, a6, r);

  1747 }

  1749 // 7 arguments --

  1750 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>

  1751 runnable_args_m_7<C, M, A0, A1, A2, A3, A4, A5, A6>* WrapRunnable(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {

  1752   return new runnable_args_m_7<C, M, A0, A1, A2, A3, A4, A5, A6>

  1753     (o, m, a0, a1, a2, a3, a4, a5, a6);

  1754 }

  1756 // 7 arguments --

  1757 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename R>

  1758 runnable_args_m_7_ret<C, M, A0, A1, A2, A3, A4, A5, A6, R>* WrapRunnableRet(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, R* r) {

  1759   return new runnable_args_m_7_ret<C, M, A0, A1, A2, A3, A4, A5, A6, R>

  1760     (o, m, a0, a1, a2, a3, a4, a5, a6, r);

  1761 }

  1763 // 8 arguments --

  1764 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>

  1765 runnable_args_nm_8<M, A0, A1, A2, A3, A4, A5, A6, A7>* WrapRunnableNM(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {

  1766   return new runnable_args_nm_8<M, A0, A1, A2, A3, A4, A5, A6, A7>

  1767     (m, a0, a1, a2, a3, a4, a5, a6, a7);

  1768 }

  1770 // 8 arguments --

  1771 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename R>

  1772 runnable_args_nm_8_ret<M, A0, A1, A2, A3, A4, A5, A6, A7, R>* WrapRunnableNMRet(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, R* r) {

  1773   return new runnable_args_nm_8_ret<M, A0, A1, A2, A3, A4, A5, A6, A7, R>

  1774     (m, a0, a1, a2, a3, a4, a5, a6, a7, r);

  1775 }

  1777 // 8 arguments --

  1778 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>

  1779 runnable_args_m_8<C, M, A0, A1, A2, A3, A4, A5, A6, A7>* WrapRunnable(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {

  1780   return new runnable_args_m_8<C, M, A0, A1, A2, A3, A4, A5, A6, A7>

  1781     (o, m, a0, a1, a2, a3, a4, a5, a6, a7);

  1782 }

  1784 // 8 arguments --

  1785 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename R>

  1786 runnable_args_m_8_ret<C, M, A0, A1, A2, A3, A4, A5, A6, A7, R>* WrapRunnableRet(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, R* r) {

  1787   return new runnable_args_m_8_ret<C, M, A0, A1, A2, A3, A4, A5, A6, A7, R>

  1788     (o, m, a0, a1, a2, a3, a4, a5, a6, a7, r);

  1789 }

  1791 // 9 arguments --

  1792 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>

  1793 runnable_args_nm_9<M, A0, A1, A2, A3, A4, A5, A6, A7, A8>* WrapRunnableNM(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {

  1794   return new runnable_args_nm_9<M, A0, A1, A2, A3, A4, A5, A6, A7, A8>

  1795     (m, a0, a1, a2, a3, a4, a5, a6, a7, a8);

  1796 }

  1798 // 9 arguments --

  1799 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename R>

  1800 runnable_args_nm_9_ret<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, R>* WrapRunnableNMRet(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, R* r) {

  1801   return new runnable_args_nm_9_ret<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, R>

  1802     (m, a0, a1, a2, a3, a4, a5, a6, a7, a8, r);

  1803 }

  1805 // 9 arguments --

  1806 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>

  1807 runnable_args_m_9<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8>* WrapRunnable(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {

  1808   return new runnable_args_m_9<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8>

  1809     (o, m, a0, a1, a2, a3, a4, a5, a6, a7, a8);

  1810 }

  1812 // 9 arguments --

  1813 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename R>

  1814 runnable_args_m_9_ret<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, R>* WrapRunnableRet(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, R* r) {

  1815   return new runnable_args_m_9_ret<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, R>

  1816     (o, m, a0, a1, a2, a3, a4, a5, a6, a7, a8, r);

  1817 }

  1819 // 10 arguments --

  1820 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>

  1821 runnable_args_nm_10<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>* WrapRunnableNM(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {

  1822   return new runnable_args_nm_10<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>

  1823     (m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);

  1824 }

  1826 // 10 arguments --

  1827 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename R>

  1828 runnable_args_nm_10_ret<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, R>* WrapRunnableNMRet(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, R* r) {

  1829   return new runnable_args_nm_10_ret<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, R>

  1830     (m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, r);

  1831 }

  1833 // 10 arguments --

  1834 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>

  1835 runnable_args_m_10<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>* WrapRunnable(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {

  1836   return new runnable_args_m_10<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>

  1837     (o, m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);

  1838 }

  1840 // 10 arguments --

  1841 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename R>

  1842 runnable_args_m_10_ret<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, R>* WrapRunnableRet(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, R* r) {

  1843   return new runnable_args_m_10_ret<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, R>

  1844     (o, m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, r);

  1845 }

  1847 // 11 arguments --

  1848 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>

  1849 runnable_args_nm_11<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>* WrapRunnableNM(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {

  1850   return new runnable_args_nm_11<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>

  1851     (m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);

  1852 }

  1854 // 11 arguments --

  1855 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename R>

  1856 runnable_args_nm_11_ret<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R>* WrapRunnableNMRet(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, R* r) {

  1857   return new runnable_args_nm_11_ret<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R>

  1858     (m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, r);

  1859 }

  1861 // 11 arguments --

  1862 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>

  1863 runnable_args_m_11<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>* WrapRunnable(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {

  1864   return new runnable_args_m_11<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>

  1865     (o, m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);

  1866 }

  1868 // 11 arguments --

  1869 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename R>

  1870 runnable_args_m_11_ret<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R>* WrapRunnableRet(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, R* r) {

  1871   return new runnable_args_m_11_ret<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R>

  1872     (o, m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, r);

  1873 }

  1875 // 12 arguments --

  1876 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>

  1877 runnable_args_nm_12<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>* WrapRunnableNM(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {

  1878   return new runnable_args_nm_12<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>

  1879     (m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

  1880 }

  1882 // 12 arguments --

  1883 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename R>

  1884 runnable_args_nm_12_ret<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R>* WrapRunnableNMRet(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, R* r) {

  1885   return new runnable_args_nm_12_ret<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R>

  1886     (m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, r);

  1887 }

  1889 // 12 arguments --

  1890 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>

  1891 runnable_args_m_12<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>* WrapRunnable(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {

  1892   return new runnable_args_m_12<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>

  1893     (o, m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);

  1894 }

  1896 // 12 arguments --

  1897 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename R>

  1898 runnable_args_m_12_ret<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R>* WrapRunnableRet(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, R* r) {

  1899   return new runnable_args_m_12_ret<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R>

  1900     (o, m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, r);

  1901 }

  1903 // 13 arguments --

  1904 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>

  1905 runnable_args_nm_13<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>* WrapRunnableNM(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {

  1906   return new runnable_args_nm_13<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>

  1907     (m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);

  1908 }

  1910 // 13 arguments --

  1911 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename R>

  1912 runnable_args_nm_13_ret<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R>* WrapRunnableNMRet(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, R* r) {

  1913   return new runnable_args_nm_13_ret<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R>

  1914     (m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, r);

  1915 }

  1917 // 13 arguments --

  1918 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>

  1919 runnable_args_m_13<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>* WrapRunnable(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {

  1920   return new runnable_args_m_13<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>

  1921     (o, m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);

  1922 }

  1924 // 13 arguments --

  1925 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename R>

  1926 runnable_args_m_13_ret<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R>* WrapRunnableRet(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, R* r) {

  1927   return new runnable_args_m_13_ret<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R>

  1928     (o, m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, r);

  1929 }

  1931 // 14 arguments --

  1932 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13>

  1933 runnable_args_nm_14<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>* WrapRunnableNM(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {

  1934   return new runnable_args_nm_14<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>

  1935     (m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);

  1936 }

  1938 // 14 arguments --

  1939 template<typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename R>

  1940 runnable_args_nm_14_ret<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R>* WrapRunnableNMRet(M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, R* r) {

  1941   return new runnable_args_nm_14_ret<M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R>

  1942     (m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, r);

  1943 }

  1945 // 14 arguments --

  1946 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13>

  1947 runnable_args_m_14<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>* WrapRunnable(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {

  1948   return new runnable_args_m_14<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>

  1949     (o, m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);

  1950 }

  1952 // 14 arguments --

  1953 template<typename C, typename M, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename R>

  1954 runnable_args_m_14_ret<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R>* WrapRunnableRet(C o, M m, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, R* r) {

  1955   return new runnable_args_m_14_ret<C, M, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R>

  1956     (o, m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, r);

  1957 }

The Tor Browser / file revision

media/mtransport/runnable_utils_generated.h@6474c204b198

media/mtransport/runnable_utils_generated.h