epoc32/include/stdapis/boost/lambda/detail/function_adaptors.hpp
author William Roberts <williamr@symbian.org>
Wed, 31 Mar 2010 12:27:01 +0100
branchSymbian2
changeset 3 e1b950c65cb4
permissions -rw-r--r--
Attempt to represent the S^2->S^3 header reorganisation as a series of "hg rename" operations
     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