1 // Boost Lambda Library -  function_adaptors.hpp ----------------------------

     2  

     3 // Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)

     4 //

     5 // Distributed under the Boost Software License, Version 1.0. (See

     6 // accompanying file LICENSE_1_0.txt or copy at

     7 // http://www.boost.org/LICENSE_1_0.txt)

     8 //

     9 // For more information, see www.boost.org

    10 

    11 

    12 #ifndef BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP

    13 #define BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP

    14 

    15 #include "boost/type_traits/same_traits.hpp"

    16 

    17 namespace boost { 

    18 namespace lambda {

    19 

    20 template <class Func> struct function_adaptor {

    21 

    22   // we do not know the return type off-hand, we must ask it from Func

    23   template <class Args> class sig { 

    24     typedef typename Args::head_type F; 

    25     typedef typename detail::remove_reference_and_cv<Func>::type plainF;

    26   public:

    27     // To sig we pass a cons list, where the head is the function object type

    28     // itself (potentially cv-qualified)

    29     // and the tail contains the types of the actual arguments to be passed

    30     // to the function object. The arguments can be cv qualified

    31     // as well.

    32     typedef typename plainF::template sig<Args>::type type;

    33   };

    34 

    35   template<class RET, class A1>

    36   static RET apply(A1& a1) {

    37     return a1();

    38   }

    39   template<class RET, class A1, class A2>

    40   static RET apply(A1& a1, A2& a2) {

    41     return a1(a2);

    42   }

    43   template<class RET, class A1, class A2, class A3>

    44   static RET apply(A1& a1, A2& a2, A3& a3) {

    45     return a1(a2, a3);

    46   }

    47   template<class RET, class A1, class A2, class A3, class A4>

    48   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4) {

    49     return a1(a2, a3, a4);

    50   }

    51   template<class RET, class A1, class A2, class A3, class A4, class A5>

    52   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {

    53     return a1(a2, a3, a4, a5);

    54   }

    55   template<class RET, class A1, class A2, class A3, class A4, class A5, class A6>

    56   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {

    57     return a1(a2, a3, a4, a5, a6);

    58   }

    59   template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 

    60            class A7>

    61   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 

    62                            A7& a7) {

    63     return a1(a2, a3, a4, a5, a6, a7);

    64   }

    65   template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 

    66            class A7, class A8>

    67   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 

    68                            A7& a7, A8& a8) {

    69     return a1(a2, a3, a4, a5, a6, a7, a8);

    70   }

    71   template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 

    72            class A7, class A8, class A9>

    73   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 

    74                            A7& a7, A8& a8, A9& a9) {

    75     return a1(a2, a3, a4, a5, a6, a7, a8, a9);

    76   }

    77   template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 

    78            class A7, class A8, class A9, class A10>

    79   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 

    80                            A7& a7, A8& a8, A9& a9, A10& a10) {

    81     return a1(a2, a3, a4, a5, a6, a7, a8, a9, a10);

    82   }

    83 };

    84 

    85 template <class Func> struct function_adaptor<const Func>; // error 

    86 

    87 // -- function adaptors with data member access

    88 template <class Object, class T>

    89 struct function_adaptor<T Object::*> {

    90 

    91   //  typedef detail::unspecified type;

    92 

    93   // T can have qualifiers and can be a reference type

    94   // We get the return type by adding const, if the object through which

    95   // the data member is accessed is const, and finally adding a reference

    96   template<class Args> class sig { 

    97     typedef typename boost::tuples::element<1, Args>::type argument_type;

    98 

    99     typedef typename detail::IF<boost::is_const<argument_type>::value,

   100       typename boost::add_const<T>::type,

   101       T

   102     >::RET properly_consted_return_type;

   103 

   104     typedef typename detail::IF<

   105         boost::is_volatile<properly_consted_return_type>::value,

   106       typename boost::add_volatile<properly_consted_return_type>::type,

   107       properly_consted_return_type

   108     >::RET properly_cvd_return_type;

   109 

   110 

   111   public:

   112     typedef typename 

   113       boost::add_reference<properly_cvd_return_type>::type type;

   114   };

   115 

   116   template <class RET>

   117   static RET apply( T Object::*data, Object& o) {

   118     return o.*data;

   119   }

   120   template <class RET>

   121   static RET apply( T Object::*data, const Object& o) {

   122     return o.*data;

   123   }

   124   template <class RET>

   125   static RET apply( T Object::*data, volatile Object& o) {

   126     return o.*data;

   127   }

   128   template <class RET>

   129   static RET apply( T Object::*data, const volatile Object& o) {

   130     return o.*data;

   131   }

   132   template <class RET>

   133   static RET apply( T Object::*data, Object* o) {

   134     return o->*data;

   135   }

   136   template <class RET>

   137   static RET apply( T Object::*data, const Object* o) {

   138     return o->*data;

   139   }

   140   template <class RET>

   141   static RET apply( T Object::*data, volatile Object* o) {

   142     return o->*data;

   143   }

   144   template <class RET>

   145   static RET apply( T Object::*data, const volatile Object* o) {

   146     return o->*data;

   147   }

   148 };

   149 

   150 // -- function adaptors with 1 argument apply

   151    

   152 template <class Result>

   153 struct function_adaptor<Result (void)> {

   154   

   155   template<class T> struct sig { typedef Result type; };

   156   template <class RET>

   157   static Result apply(Result (*func)()) {

   158     return func();

   159   }

   160 };

   161 

   162 template <class Result>

   163 struct function_adaptor<Result (*)(void)> {

   164 

   165   template<class T> struct sig { typedef Result type; };

   166   template <class RET>

   167   static Result apply(Result (*func)()) {

   168     return func();

   169   }

   170 };

   171 

   172 

   173 // -- function adaptors with 2 argument apply

   174 template <class Object, class Result>

   175 struct function_adaptor<Result (Object::*)() const> {

   176 

   177   template<class T> struct sig { typedef Result type; };

   178   template <class RET>

   179   static Result apply( Result (Object::*func)() const, const Object* o) {

   180     return (o->*func)();

   181   }

   182   template <class RET>

   183   static Result apply( Result (Object::*func)() const, const Object& o) {

   184     return (o.*func)();

   185   }

   186 };

   187 

   188 template <class Object, class Result>

   189 struct function_adaptor<Result (Object::*)()> {

   190 

   191   template<class T> struct sig { typedef Result type; };

   192   template <class RET>

   193   static Result apply( Result (Object::*func)(), Object* o) {

   194     return (o->*func)();

   195   }

   196   template <class RET>

   197   static Result apply( Result (Object::*func)(), Object& o) {

   198     return (o.*func)();

   199   }

   200 };

   201 

   202 template <class Arg1, class Result>

   203 struct function_adaptor<Result (Arg1)> {

   204 

   205   template<class T> struct sig { typedef Result type; };

   206   template <class RET, class A1>

   207   static Result apply(Result (*func)(Arg1), A1& a1) {

   208     return func(a1);

   209   }

   210 };

   211 

   212 template <class Arg1, class Result>

   213 struct function_adaptor<Result (*)(Arg1)> {

   214 

   215   template<class T> struct sig { typedef Result type; };

   216   template <class RET, class A1>

   217   static Result apply(Result (*func)(Arg1), A1& a1) {

   218     return func(a1);

   219   }

   220 };

   221 

   222 

   223 // -- function adaptors with 3 argument apply

   224 template <class Object, class Arg1, class Result>

   225 struct function_adaptor<Result (Object::*)(Arg1) const> {

   226 

   227   template<class T> struct sig { typedef Result type; };

   228   template <class RET, class A1>

   229   static Result apply( Result (Object::*func)(Arg1) const, const Object* o, 

   230     A1& a1) {

   231     return (o->*func)(a1);

   232   }

   233   template <class RET, class A1>

   234   static Result apply( Result (Object::*func)(Arg1) const, const Object& o, 

   235     A1& a1) {

   236     return (o.*func)(a1);

   237   }

   238 };

   239 

   240 template <class Object, class Arg1, class Result>

   241 struct function_adaptor<Result (Object::*)(Arg1)> {

   242 

   243   template<class T> struct sig { typedef Result type; };

   244   template <class RET, class A1>

   245   static Result apply( Result (Object::*func)(Arg1), Object* o, A1& a1) {

   246     return (o->*func)(a1);

   247   }

   248   template <class RET, class A1>

   249   static Result apply( Result (Object::*func)(Arg1), Object& o, A1& a1) {

   250     return (o.*func)(a1);

   251   }

   252 };

   253 

   254 template <class Arg1, class Arg2, class Result>

   255 struct function_adaptor<Result (Arg1, Arg2)> {

   256 

   257   template<class T> struct sig { typedef Result type; };

   258   template <class RET, class A1, class A2>

   259   static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) {

   260     return func(a1, a2);

   261   }

   262 };

   263 

   264 template <class Arg1, class Arg2, class Result>

   265 struct function_adaptor<Result (*)(Arg1, Arg2)> {

   266 

   267   template<class T> struct sig { typedef Result type; };

   268   template <class RET, class A1, class A2>

   269   static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) {

   270     return func(a1, a2);

   271   }

   272 };

   273 

   274 

   275 // -- function adaptors with 4 argument apply

   276 template <class Object, class Arg1, class Arg2, class Result>

   277 struct function_adaptor<Result (Object::*)(Arg1, Arg2) const> {

   278 

   279   template<class T> struct sig { typedef Result type; };

   280   template <class RET, class A1, class A2>

   281   static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object* o, A1& a1, A2& a2) {

   282     return (o->*func)(a1, a2);

   283   }

   284   template <class RET, class A1, class A2>

   285   static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object& o, A1& a1, A2& a2) {

   286     return (o.*func)(a1, a2);

   287   }

   288 };

   289 

   290 template <class Object, class Arg1, class Arg2, class Result>

   291 struct function_adaptor<Result (Object::*)(Arg1, Arg2)> {

   292 

   293   template<class T> struct sig { typedef Result type; };

   294   template <class RET, class A1, class A2>

   295   static Result apply( Result (Object::*func)(Arg1, Arg2), Object* o, A1& a1, A2& a2) {

   296     return (o->*func)(a1, a2);

   297   }

   298   template <class RET, class A1, class A2>

   299   static Result apply( Result (Object::*func)(Arg1, Arg2), Object& o, A1& a1, A2& a2) {

   300     return (o.*func)(a1, a2);

   301   }

   302 };

   303 

   304 template <class Arg1, class Arg2, class Arg3, class Result>

   305 struct function_adaptor<Result (Arg1, Arg2, Arg3)> {

   306 

   307   template<class T> struct sig { typedef Result type; };

   308   template <class RET, class A1, class A2, class A3>

   309   static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) {

   310     return func(a1, a2, a3);

   311   }

   312 };

   313 

   314 template <class Arg1, class Arg2, class Arg3, class Result>

   315 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3)> {

   316 

   317   template<class T> struct sig { typedef Result type; };

   318   template <class RET, class A1, class A2, class A3>

   319   static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) {

   320     return func(a1, a2, a3);

   321   }

   322 };

   323 

   324 

   325 // -- function adaptors with 5 argument apply

   326 template <class Object, class Arg1, class Arg2, class Arg3, class Result>

   327 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3) const> {

   328 

   329   template<class T> struct sig { typedef Result type; };

   330   template <class RET, class A1, class A2, class A3>

   331   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object* o, A1& a1, A2& a2, A3& a3) {

   332     return (o->*func)(a1, a2, a3);

   333   }

   334   template <class RET, class A1, class A2, class A3>

   335   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object& o, A1& a1, A2& a2, A3& a3) {

   336     return (o.*func)(a1, a2, a3);

   337   }

   338 };

   339 

   340 template <class Object, class Arg1, class Arg2, class Arg3, class Result>

   341 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3)> {

   342 

   343   template<class T> struct sig { typedef Result type; };

   344   template <class RET, class A1, class A2, class A3>

   345   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object* o, A1& a1, A2& a2, A3& a3) {

   346     return (o->*func)(a1, a2, a3);

   347   }

   348   template <class RET, class A1, class A2, class A3>

   349   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object& o, A1& a1, A2& a2, A3& a3) {

   350     return (o.*func)(a1, a2, a3);

   351   }

   352 };

   353 

   354 template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>

   355 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4)> {

   356 

   357   template<class T> struct sig { typedef Result type; };

   358   template <class RET, class A1, class A2, class A3, class A4>

   359   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) {

   360     return func(a1, a2, a3, a4);

   361   }

   362 };

   363 

   364 template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>

   365 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4)> {

   366 

   367   template<class T> struct sig { typedef Result type; };

   368   template <class RET, class A1, class A2, class A3, class A4>

   369   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) {

   370     return func(a1, a2, a3, a4);

   371   }

   372 };

   373 

   374 

   375 // -- function adaptors with 6 argument apply

   376 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>

   377 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4) const> {

   378 

   379   template<class T> struct sig { typedef Result type; };

   380   template <class RET, class A1, class A2, class A3, class A4>

   381   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4) {

   382     return (o->*func)(a1, a2, a3, a4);

   383   }

   384   template <class RET, class A1, class A2, class A3, class A4>

   385   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4) {

   386     return (o.*func)(a1, a2, a3, a4);

   387   }

   388 };

   389 

   390 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>

   391 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4)> {

   392 

   393   template<class T> struct sig { typedef Result type; };

   394   template <class RET, class A1, class A2, class A3, class A4>

   395   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object* o, A1& a1, A2& a2, A3& a3, A4& a4) {

   396     return (o->*func)(a1, a2, a3, a4);

   397   }

   398   template <class RET, class A1, class A2, class A3, class A4>

   399   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object& o, A1& a1, A2& a2, A3& a3, A4& a4) {

   400     return (o.*func)(a1, a2, a3, a4);

   401   }

   402 };

   403 

   404 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>

   405 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5)> {

   406 

   407   template<class T> struct sig { typedef Result type; };

   408   template <class RET, class A1, class A2, class A3, class A4, class A5>

   409   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {

   410     return func(a1, a2, a3, a4, a5);

   411   }

   412 };

   413 

   414 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>

   415 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {

   416 

   417   template<class T> struct sig { typedef Result type; };

   418   template <class RET, class A1, class A2, class A3, class A4, class A5>

   419   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {

   420     return func(a1, a2, a3, a4, a5);

   421   }

   422 };

   423 

   424 

   425 // -- function adaptors with 7 argument apply

   426 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>

   427 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5) const> {

   428 

   429   template<class T> struct sig { typedef Result type; };

   430   template <class RET, class A1, class A2, class A3, class A4, class A5>

   431   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {

   432     return (o->*func)(a1, a2, a3, a4, a5);

   433   }

   434   template <class RET, class A1, class A2, class A3, class A4, class A5>

   435   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {

   436     return (o.*func)(a1, a2, a3, a4, a5);

   437   }

   438 };

   439 

   440 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>

   441 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {

   442 

   443   template<class T> struct sig { typedef Result type; };

   444   template <class RET, class A1, class A2, class A3, class A4, class A5>

   445   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {

   446     return (o->*func)(a1, a2, a3, a4, a5);

   447   }

   448   template <class RET, class A1, class A2, class A3, class A4, class A5>

   449   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {

   450     return (o.*func)(a1, a2, a3, a4, a5);

   451   }

   452 };

   453 

   454 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>

   455 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {

   456 

   457   template<class T> struct sig { typedef Result type; };

   458   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>

   459   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {

   460     return func(a1, a2, a3, a4, a5, a6);

   461   }

   462 };

   463 

   464 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>

   465 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {

   466 

   467   template<class T> struct sig { typedef Result type; };

   468   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>

   469   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {

   470     return func(a1, a2, a3, a4, a5, a6);

   471   }

   472 };

   473 

   474 

   475 // -- function adaptors with 8 argument apply

   476 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>

   477 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const> {

   478 

   479   template<class T> struct sig { typedef Result type; };

   480   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>

   481   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {

   482     return (o->*func)(a1, a2, a3, a4, a5, a6);

   483   }

   484   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>

   485   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {

   486     return (o.*func)(a1, a2, a3, a4, a5, a6);

   487   }

   488 };

   489 

   490 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>

   491 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {

   492 

   493   template<class T> struct sig { typedef Result type; };

   494   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>

   495   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {

   496     return (o->*func)(a1, a2, a3, a4, a5, a6);

   497   }

   498   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>

   499   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {

   500     return (o.*func)(a1, a2, a3, a4, a5, a6);

   501   }

   502 };

   503 

   504 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>

   505 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {

   506 

   507   template<class T> struct sig { typedef Result type; };

   508   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>

   509   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {

   510     return func(a1, a2, a3, a4, a5, a6, a7);

   511   }

   512 };

   513 

   514 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>

   515 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {

   516 

   517   template<class T> struct sig { typedef Result type; };

   518   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>

   519   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {

   520     return func(a1, a2, a3, a4, a5, a6, a7);

   521   }

   522 };

   523 

   524 

   525 // -- function adaptors with 9 argument apply

   526 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>

   527 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const> {

   528 

   529   template<class T> struct sig { typedef Result type; };

   530   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>

   531   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {

   532     return (o->*func)(a1, a2, a3, a4, a5, a6, a7);

   533   }

   534   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>

   535   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {

   536     return (o.*func)(a1, a2, a3, a4, a5, a6, a7);

   537   }

   538 };

   539 

   540 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>

   541 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {

   542 

   543   template<class T> struct sig { typedef Result type; };

   544   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>

   545   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {

   546     return (o->*func)(a1, a2, a3, a4, a5, a6, a7);

   547   }

   548   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>

   549   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {

   550     return (o.*func)(a1, a2, a3, a4, a5, a6, a7);

   551   }

   552 };

   553 

   554 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>

   555 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {

   556 

   557   template<class T> struct sig { typedef Result type; };

   558   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>

   559   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {

   560     return func(a1, a2, a3, a4, a5, a6, a7, a8);

   561   }

   562 };

   563 

   564 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>

   565 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {

   566 

   567   template<class T> struct sig { typedef Result type; };

   568   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>

   569   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {

   570     return func(a1, a2, a3, a4, a5, a6, a7, a8);

   571   }

   572 };

   573 

   574 

   575 // -- function adaptors with 10 argument apply

   576 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>

   577 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const> {

   578 

   579   template<class T> struct sig { typedef Result type; };

   580   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>

   581   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {

   582     return (o->*func)(a1, a2, a3, a4, a5, a6, a7, a8);

   583   }

   584   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>

   585   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {

   586     return (o.*func)(a1, a2, a3, a4, a5, a6, a7, a8);

   587   }

   588 };

   589 

   590 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>

   591 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {

   592 

   593   template<class T> struct sig { typedef Result type; };

   594   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>

   595   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {

   596     return (o->*func)(a1, a2, a3, a4, a5, a6, a7, a8);

   597   }

   598   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>

   599   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {

   600     return (o.*func)(a1, a2, a3, a4, a5, a6, a7, a8);

   601   }

   602 };

   603 

   604 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result>

   605 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {

   606 

   607   template<class T> struct sig { typedef Result type; };

   608   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>

   609   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) {

   610     return func(a1, a2, a3, a4, a5, a6, a7, a8, a9);

   611   }

   612 };

   613 

   614 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result>

   615 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {

   616 

   617   template<class T> struct sig { typedef Result type; };

   618   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>

   619   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) {

   620     return func(a1, a2, a3, a4, a5, a6, a7, a8, a9);

   621   }

   622 };

   623 

   624 } // namespace lambda

   625 } // namespace boost

   626 

   627 #endif

   628 

   629 

   630 

   631 

   632 

   633 

   634 

   635 

   636 

   637 

   638 

   639 

   640