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
williamr@2
     1
// Boost Lambda Library -  function_adaptors.hpp ----------------------------
williamr@2
     2
 
williamr@2
     3
// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
williamr@2
     4
//
williamr@2
     5
// Distributed under the Boost Software License, Version 1.0. (See
williamr@2
     6
// accompanying file LICENSE_1_0.txt or copy at
williamr@2
     7
// http://www.boost.org/LICENSE_1_0.txt)
williamr@2
     8
//
williamr@2
     9
// For more information, see www.boost.org
williamr@2
    10
williamr@2
    11
williamr@2
    12
#ifndef BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP
williamr@2
    13
#define BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP
williamr@2
    14
williamr@2
    15
#include "boost/type_traits/same_traits.hpp"
williamr@2
    16
williamr@2
    17
namespace boost { 
williamr@2
    18
namespace lambda {
williamr@2
    19
williamr@2
    20
template <class Func> struct function_adaptor {
williamr@2
    21
williamr@2
    22
  // we do not know the return type off-hand, we must ask it from Func
williamr@2
    23
  template <class Args> class sig { 
williamr@2
    24
    typedef typename Args::head_type F; 
williamr@2
    25
    typedef typename detail::remove_reference_and_cv<Func>::type plainF;
williamr@2
    26
  public:
williamr@2
    27
    // To sig we pass a cons list, where the head is the function object type
williamr@2
    28
    // itself (potentially cv-qualified)
williamr@2
    29
    // and the tail contains the types of the actual arguments to be passed
williamr@2
    30
    // to the function object. The arguments can be cv qualified
williamr@2
    31
    // as well.
williamr@2
    32
    typedef typename plainF::template sig<Args>::type type;
williamr@2
    33
  };
williamr@2
    34
williamr@2
    35
  template<class RET, class A1>
williamr@2
    36
  static RET apply(A1& a1) {
williamr@2
    37
    return a1();
williamr@2
    38
  }
williamr@2
    39
  template<class RET, class A1, class A2>
williamr@2
    40
  static RET apply(A1& a1, A2& a2) {
williamr@2
    41
    return a1(a2);
williamr@2
    42
  }
williamr@2
    43
  template<class RET, class A1, class A2, class A3>
williamr@2
    44
  static RET apply(A1& a1, A2& a2, A3& a3) {
williamr@2
    45
    return a1(a2, a3);
williamr@2
    46
  }
williamr@2
    47
  template<class RET, class A1, class A2, class A3, class A4>
williamr@2
    48
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4) {
williamr@2
    49
    return a1(a2, a3, a4);
williamr@2
    50
  }
williamr@2
    51
  template<class RET, class A1, class A2, class A3, class A4, class A5>
williamr@2
    52
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
williamr@2
    53
    return a1(a2, a3, a4, a5);
williamr@2
    54
  }
williamr@2
    55
  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6>
williamr@2
    56
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
williamr@2
    57
    return a1(a2, a3, a4, a5, a6);
williamr@2
    58
  }
williamr@2
    59
  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
williamr@2
    60
           class A7>
williamr@2
    61
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
williamr@2
    62
                           A7& a7) {
williamr@2
    63
    return a1(a2, a3, a4, a5, a6, a7);
williamr@2
    64
  }
williamr@2
    65
  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
williamr@2
    66
           class A7, class A8>
williamr@2
    67
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
williamr@2
    68
                           A7& a7, A8& a8) {
williamr@2
    69
    return a1(a2, a3, a4, a5, a6, a7, a8);
williamr@2
    70
  }
williamr@2
    71
  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
williamr@2
    72
           class A7, class A8, class A9>
williamr@2
    73
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
williamr@2
    74
                           A7& a7, A8& a8, A9& a9) {
williamr@2
    75
    return a1(a2, a3, a4, a5, a6, a7, a8, a9);
williamr@2
    76
  }
williamr@2
    77
  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
williamr@2
    78
           class A7, class A8, class A9, class A10>
williamr@2
    79
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
williamr@2
    80
                           A7& a7, A8& a8, A9& a9, A10& a10) {
williamr@2
    81
    return a1(a2, a3, a4, a5, a6, a7, a8, a9, a10);
williamr@2
    82
  }
williamr@2
    83
};
williamr@2
    84
williamr@2
    85
template <class Func> struct function_adaptor<const Func>; // error 
williamr@2
    86
williamr@2
    87
// -- function adaptors with data member access
williamr@2
    88
template <class Object, class T>
williamr@2
    89
struct function_adaptor<T Object::*> {
williamr@2
    90
williamr@2
    91
  //  typedef detail::unspecified type;
williamr@2
    92
williamr@2
    93
  // T can have qualifiers and can be a reference type
williamr@2
    94
  // We get the return type by adding const, if the object through which
williamr@2
    95
  // the data member is accessed is const, and finally adding a reference
williamr@2
    96
  template<class Args> class sig { 
williamr@2
    97
    typedef typename boost::tuples::element<1, Args>::type argument_type;
williamr@2
    98
williamr@2
    99
    typedef typename detail::IF<boost::is_const<argument_type>::value,
williamr@2
   100
      typename boost::add_const<T>::type,
williamr@2
   101
      T
williamr@2
   102
    >::RET properly_consted_return_type;
williamr@2
   103
williamr@2
   104
    typedef typename detail::IF<
williamr@2
   105
        boost::is_volatile<properly_consted_return_type>::value,
williamr@2
   106
      typename boost::add_volatile<properly_consted_return_type>::type,
williamr@2
   107
      properly_consted_return_type
williamr@2
   108
    >::RET properly_cvd_return_type;
williamr@2
   109
williamr@2
   110
williamr@2
   111
  public:
williamr@2
   112
    typedef typename 
williamr@2
   113
      boost::add_reference<properly_cvd_return_type>::type type;
williamr@2
   114
  };
williamr@2
   115
williamr@2
   116
  template <class RET>
williamr@2
   117
  static RET apply( T Object::*data, Object& o) {
williamr@2
   118
    return o.*data;
williamr@2
   119
  }
williamr@2
   120
  template <class RET>
williamr@2
   121
  static RET apply( T Object::*data, const Object& o) {
williamr@2
   122
    return o.*data;
williamr@2
   123
  }
williamr@2
   124
  template <class RET>
williamr@2
   125
  static RET apply( T Object::*data, volatile Object& o) {
williamr@2
   126
    return o.*data;
williamr@2
   127
  }
williamr@2
   128
  template <class RET>
williamr@2
   129
  static RET apply( T Object::*data, const volatile Object& o) {
williamr@2
   130
    return o.*data;
williamr@2
   131
  }
williamr@2
   132
  template <class RET>
williamr@2
   133
  static RET apply( T Object::*data, Object* o) {
williamr@2
   134
    return o->*data;
williamr@2
   135
  }
williamr@2
   136
  template <class RET>
williamr@2
   137
  static RET apply( T Object::*data, const Object* o) {
williamr@2
   138
    return o->*data;
williamr@2
   139
  }
williamr@2
   140
  template <class RET>
williamr@2
   141
  static RET apply( T Object::*data, volatile Object* o) {
williamr@2
   142
    return o->*data;
williamr@2
   143
  }
williamr@2
   144
  template <class RET>
williamr@2
   145
  static RET apply( T Object::*data, const volatile Object* o) {
williamr@2
   146
    return o->*data;
williamr@2
   147
  }
williamr@2
   148
};
williamr@2
   149
williamr@2
   150
// -- function adaptors with 1 argument apply
williamr@2
   151
   
williamr@2
   152
template <class Result>
williamr@2
   153
struct function_adaptor<Result (void)> {
williamr@2
   154
  
williamr@2
   155
  template<class T> struct sig { typedef Result type; };
williamr@2
   156
  template <class RET>
williamr@2
   157
  static Result apply(Result (*func)()) {
williamr@2
   158
    return func();
williamr@2
   159
  }
williamr@2
   160
};
williamr@2
   161
williamr@2
   162
template <class Result>
williamr@2
   163
struct function_adaptor<Result (*)(void)> {
williamr@2
   164
williamr@2
   165
  template<class T> struct sig { typedef Result type; };
williamr@2
   166
  template <class RET>
williamr@2
   167
  static Result apply(Result (*func)()) {
williamr@2
   168
    return func();
williamr@2
   169
  }
williamr@2
   170
};
williamr@2
   171
williamr@2
   172
williamr@2
   173
// -- function adaptors with 2 argument apply
williamr@2
   174
template <class Object, class Result>
williamr@2
   175
struct function_adaptor<Result (Object::*)() const> {
williamr@2
   176
williamr@2
   177
  template<class T> struct sig { typedef Result type; };
williamr@2
   178
  template <class RET>
williamr@2
   179
  static Result apply( Result (Object::*func)() const, const Object* o) {
williamr@2
   180
    return (o->*func)();
williamr@2
   181
  }
williamr@2
   182
  template <class RET>
williamr@2
   183
  static Result apply( Result (Object::*func)() const, const Object& o) {
williamr@2
   184
    return (o.*func)();
williamr@2
   185
  }
williamr@2
   186
};
williamr@2
   187
williamr@2
   188
template <class Object, class Result>
williamr@2
   189
struct function_adaptor<Result (Object::*)()> {
williamr@2
   190
williamr@2
   191
  template<class T> struct sig { typedef Result type; };
williamr@2
   192
  template <class RET>
williamr@2
   193
  static Result apply( Result (Object::*func)(), Object* o) {
williamr@2
   194
    return (o->*func)();
williamr@2
   195
  }
williamr@2
   196
  template <class RET>
williamr@2
   197
  static Result apply( Result (Object::*func)(), Object& o) {
williamr@2
   198
    return (o.*func)();
williamr@2
   199
  }
williamr@2
   200
};
williamr@2
   201
williamr@2
   202
template <class Arg1, class Result>
williamr@2
   203
struct function_adaptor<Result (Arg1)> {
williamr@2
   204
williamr@2
   205
  template<class T> struct sig { typedef Result type; };
williamr@2
   206
  template <class RET, class A1>
williamr@2
   207
  static Result apply(Result (*func)(Arg1), A1& a1) {
williamr@2
   208
    return func(a1);
williamr@2
   209
  }
williamr@2
   210
};
williamr@2
   211
williamr@2
   212
template <class Arg1, class Result>
williamr@2
   213
struct function_adaptor<Result (*)(Arg1)> {
williamr@2
   214
williamr@2
   215
  template<class T> struct sig { typedef Result type; };
williamr@2
   216
  template <class RET, class A1>
williamr@2
   217
  static Result apply(Result (*func)(Arg1), A1& a1) {
williamr@2
   218
    return func(a1);
williamr@2
   219
  }
williamr@2
   220
};
williamr@2
   221
williamr@2
   222
williamr@2
   223
// -- function adaptors with 3 argument apply
williamr@2
   224
template <class Object, class Arg1, class Result>
williamr@2
   225
struct function_adaptor<Result (Object::*)(Arg1) const> {
williamr@2
   226
williamr@2
   227
  template<class T> struct sig { typedef Result type; };
williamr@2
   228
  template <class RET, class A1>
williamr@2
   229
  static Result apply( Result (Object::*func)(Arg1) const, const Object* o, 
williamr@2
   230
    A1& a1) {
williamr@2
   231
    return (o->*func)(a1);
williamr@2
   232
  }
williamr@2
   233
  template <class RET, class A1>
williamr@2
   234
  static Result apply( Result (Object::*func)(Arg1) const, const Object& o, 
williamr@2
   235
    A1& a1) {
williamr@2
   236
    return (o.*func)(a1);
williamr@2
   237
  }
williamr@2
   238
};
williamr@2
   239
williamr@2
   240
template <class Object, class Arg1, class Result>
williamr@2
   241
struct function_adaptor<Result (Object::*)(Arg1)> {
williamr@2
   242
williamr@2
   243
  template<class T> struct sig { typedef Result type; };
williamr@2
   244
  template <class RET, class A1>
williamr@2
   245
  static Result apply( Result (Object::*func)(Arg1), Object* o, A1& a1) {
williamr@2
   246
    return (o->*func)(a1);
williamr@2
   247
  }
williamr@2
   248
  template <class RET, class A1>
williamr@2
   249
  static Result apply( Result (Object::*func)(Arg1), Object& o, A1& a1) {
williamr@2
   250
    return (o.*func)(a1);
williamr@2
   251
  }
williamr@2
   252
};
williamr@2
   253
williamr@2
   254
template <class Arg1, class Arg2, class Result>
williamr@2
   255
struct function_adaptor<Result (Arg1, Arg2)> {
williamr@2
   256
williamr@2
   257
  template<class T> struct sig { typedef Result type; };
williamr@2
   258
  template <class RET, class A1, class A2>
williamr@2
   259
  static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) {
williamr@2
   260
    return func(a1, a2);
williamr@2
   261
  }
williamr@2
   262
};
williamr@2
   263
williamr@2
   264
template <class Arg1, class Arg2, class Result>
williamr@2
   265
struct function_adaptor<Result (*)(Arg1, Arg2)> {
williamr@2
   266
williamr@2
   267
  template<class T> struct sig { typedef Result type; };
williamr@2
   268
  template <class RET, class A1, class A2>
williamr@2
   269
  static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) {
williamr@2
   270
    return func(a1, a2);
williamr@2
   271
  }
williamr@2
   272
};
williamr@2
   273
williamr@2
   274
williamr@2
   275
// -- function adaptors with 4 argument apply
williamr@2
   276
template <class Object, class Arg1, class Arg2, class Result>
williamr@2
   277
struct function_adaptor<Result (Object::*)(Arg1, Arg2) const> {
williamr@2
   278
williamr@2
   279
  template<class T> struct sig { typedef Result type; };
williamr@2
   280
  template <class RET, class A1, class A2>
williamr@2
   281
  static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object* o, A1& a1, A2& a2) {
williamr@2
   282
    return (o->*func)(a1, a2);
williamr@2
   283
  }
williamr@2
   284
  template <class RET, class A1, class A2>
williamr@2
   285
  static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object& o, A1& a1, A2& a2) {
williamr@2
   286
    return (o.*func)(a1, a2);
williamr@2
   287
  }
williamr@2
   288
};
williamr@2
   289
williamr@2
   290
template <class Object, class Arg1, class Arg2, class Result>
williamr@2
   291
struct function_adaptor<Result (Object::*)(Arg1, Arg2)> {
williamr@2
   292
williamr@2
   293
  template<class T> struct sig { typedef Result type; };
williamr@2
   294
  template <class RET, class A1, class A2>
williamr@2
   295
  static Result apply( Result (Object::*func)(Arg1, Arg2), Object* o, A1& a1, A2& a2) {
williamr@2
   296
    return (o->*func)(a1, a2);
williamr@2
   297
  }
williamr@2
   298
  template <class RET, class A1, class A2>
williamr@2
   299
  static Result apply( Result (Object::*func)(Arg1, Arg2), Object& o, A1& a1, A2& a2) {
williamr@2
   300
    return (o.*func)(a1, a2);
williamr@2
   301
  }
williamr@2
   302
};
williamr@2
   303
williamr@2
   304
template <class Arg1, class Arg2, class Arg3, class Result>
williamr@2
   305
struct function_adaptor<Result (Arg1, Arg2, Arg3)> {
williamr@2
   306
williamr@2
   307
  template<class T> struct sig { typedef Result type; };
williamr@2
   308
  template <class RET, class A1, class A2, class A3>
williamr@2
   309
  static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) {
williamr@2
   310
    return func(a1, a2, a3);
williamr@2
   311
  }
williamr@2
   312
};
williamr@2
   313
williamr@2
   314
template <class Arg1, class Arg2, class Arg3, class Result>
williamr@2
   315
struct function_adaptor<Result (*)(Arg1, Arg2, Arg3)> {
williamr@2
   316
williamr@2
   317
  template<class T> struct sig { typedef Result type; };
williamr@2
   318
  template <class RET, class A1, class A2, class A3>
williamr@2
   319
  static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) {
williamr@2
   320
    return func(a1, a2, a3);
williamr@2
   321
  }
williamr@2
   322
};
williamr@2
   323
williamr@2
   324
williamr@2
   325
// -- function adaptors with 5 argument apply
williamr@2
   326
template <class Object, class Arg1, class Arg2, class Arg3, class Result>
williamr@2
   327
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3) const> {
williamr@2
   328
williamr@2
   329
  template<class T> struct sig { typedef Result type; };
williamr@2
   330
  template <class RET, class A1, class A2, class A3>
williamr@2
   331
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object* o, A1& a1, A2& a2, A3& a3) {
williamr@2
   332
    return (o->*func)(a1, a2, a3);
williamr@2
   333
  }
williamr@2
   334
  template <class RET, class A1, class A2, class A3>
williamr@2
   335
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object& o, A1& a1, A2& a2, A3& a3) {
williamr@2
   336
    return (o.*func)(a1, a2, a3);
williamr@2
   337
  }
williamr@2
   338
};
williamr@2
   339
williamr@2
   340
template <class Object, class Arg1, class Arg2, class Arg3, class Result>
williamr@2
   341
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3)> {
williamr@2
   342
williamr@2
   343
  template<class T> struct sig { typedef Result type; };
williamr@2
   344
  template <class RET, class A1, class A2, class A3>
williamr@2
   345
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object* o, A1& a1, A2& a2, A3& a3) {
williamr@2
   346
    return (o->*func)(a1, a2, a3);
williamr@2
   347
  }
williamr@2
   348
  template <class RET, class A1, class A2, class A3>
williamr@2
   349
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object& o, A1& a1, A2& a2, A3& a3) {
williamr@2
   350
    return (o.*func)(a1, a2, a3);
williamr@2
   351
  }
williamr@2
   352
};
williamr@2
   353
williamr@2
   354
template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>
williamr@2
   355
struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4)> {
williamr@2
   356
williamr@2
   357
  template<class T> struct sig { typedef Result type; };
williamr@2
   358
  template <class RET, class A1, class A2, class A3, class A4>
williamr@2
   359
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) {
williamr@2
   360
    return func(a1, a2, a3, a4);
williamr@2
   361
  }
williamr@2
   362
};
williamr@2
   363
williamr@2
   364
template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>
williamr@2
   365
struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4)> {
williamr@2
   366
williamr@2
   367
  template<class T> struct sig { typedef Result type; };
williamr@2
   368
  template <class RET, class A1, class A2, class A3, class A4>
williamr@2
   369
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) {
williamr@2
   370
    return func(a1, a2, a3, a4);
williamr@2
   371
  }
williamr@2
   372
};
williamr@2
   373
williamr@2
   374
williamr@2
   375
// -- function adaptors with 6 argument apply
williamr@2
   376
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>
williamr@2
   377
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4) const> {
williamr@2
   378
williamr@2
   379
  template<class T> struct sig { typedef Result type; };
williamr@2
   380
  template <class RET, class A1, class A2, class A3, class A4>
williamr@2
   381
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4) {
williamr@2
   382
    return (o->*func)(a1, a2, a3, a4);
williamr@2
   383
  }
williamr@2
   384
  template <class RET, class A1, class A2, class A3, class A4>
williamr@2
   385
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4) {
williamr@2
   386
    return (o.*func)(a1, a2, a3, a4);
williamr@2
   387
  }
williamr@2
   388
};
williamr@2
   389
williamr@2
   390
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>
williamr@2
   391
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4)> {
williamr@2
   392
williamr@2
   393
  template<class T> struct sig { typedef Result type; };
williamr@2
   394
  template <class RET, class A1, class A2, class A3, class A4>
williamr@2
   395
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object* o, A1& a1, A2& a2, A3& a3, A4& a4) {
williamr@2
   396
    return (o->*func)(a1, a2, a3, a4);
williamr@2
   397
  }
williamr@2
   398
  template <class RET, class A1, class A2, class A3, class A4>
williamr@2
   399
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object& o, A1& a1, A2& a2, A3& a3, A4& a4) {
williamr@2
   400
    return (o.*func)(a1, a2, a3, a4);
williamr@2
   401
  }
williamr@2
   402
};
williamr@2
   403
williamr@2
   404
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
williamr@2
   405
struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5)> {
williamr@2
   406
williamr@2
   407
  template<class T> struct sig { typedef Result type; };
williamr@2
   408
  template <class RET, class A1, class A2, class A3, class A4, class A5>
williamr@2
   409
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
williamr@2
   410
    return func(a1, a2, a3, a4, a5);
williamr@2
   411
  }
williamr@2
   412
};
williamr@2
   413
williamr@2
   414
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
williamr@2
   415
struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {
williamr@2
   416
williamr@2
   417
  template<class T> struct sig { typedef Result type; };
williamr@2
   418
  template <class RET, class A1, class A2, class A3, class A4, class A5>
williamr@2
   419
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
williamr@2
   420
    return func(a1, a2, a3, a4, a5);
williamr@2
   421
  }
williamr@2
   422
};
williamr@2
   423
williamr@2
   424
williamr@2
   425
// -- function adaptors with 7 argument apply
williamr@2
   426
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
williamr@2
   427
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5) const> {
williamr@2
   428
williamr@2
   429
  template<class T> struct sig { typedef Result type; };
williamr@2
   430
  template <class RET, class A1, class A2, class A3, class A4, class A5>
williamr@2
   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) {
williamr@2
   432
    return (o->*func)(a1, a2, a3, a4, a5);
williamr@2
   433
  }
williamr@2
   434
  template <class RET, class A1, class A2, class A3, class A4, class A5>
williamr@2
   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) {
williamr@2
   436
    return (o.*func)(a1, a2, a3, a4, a5);
williamr@2
   437
  }
williamr@2
   438
};
williamr@2
   439
williamr@2
   440
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
williamr@2
   441
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {
williamr@2
   442
williamr@2
   443
  template<class T> struct sig { typedef Result type; };
williamr@2
   444
  template <class RET, class A1, class A2, class A3, class A4, class A5>
williamr@2
   445
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
williamr@2
   446
    return (o->*func)(a1, a2, a3, a4, a5);
williamr@2
   447
  }
williamr@2
   448
  template <class RET, class A1, class A2, class A3, class A4, class A5>
williamr@2
   449
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
williamr@2
   450
    return (o.*func)(a1, a2, a3, a4, a5);
williamr@2
   451
  }
williamr@2
   452
};
williamr@2
   453
williamr@2
   454
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
williamr@2
   455
struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
williamr@2
   456
williamr@2
   457
  template<class T> struct sig { typedef Result type; };
williamr@2
   458
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
williamr@2
   459
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
williamr@2
   460
    return func(a1, a2, a3, a4, a5, a6);
williamr@2
   461
  }
williamr@2
   462
};
williamr@2
   463
williamr@2
   464
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
williamr@2
   465
struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
williamr@2
   466
williamr@2
   467
  template<class T> struct sig { typedef Result type; };
williamr@2
   468
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
williamr@2
   469
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
williamr@2
   470
    return func(a1, a2, a3, a4, a5, a6);
williamr@2
   471
  }
williamr@2
   472
};
williamr@2
   473
williamr@2
   474
williamr@2
   475
// -- function adaptors with 8 argument apply
williamr@2
   476
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
williamr@2
   477
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const> {
williamr@2
   478
williamr@2
   479
  template<class T> struct sig { typedef Result type; };
williamr@2
   480
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
williamr@2
   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) {
williamr@2
   482
    return (o->*func)(a1, a2, a3, a4, a5, a6);
williamr@2
   483
  }
williamr@2
   484
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
williamr@2
   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) {
williamr@2
   486
    return (o.*func)(a1, a2, a3, a4, a5, a6);
williamr@2
   487
  }
williamr@2
   488
};
williamr@2
   489
williamr@2
   490
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
williamr@2
   491
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
williamr@2
   492
williamr@2
   493
  template<class T> struct sig { typedef Result type; };
williamr@2
   494
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
williamr@2
   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) {
williamr@2
   496
    return (o->*func)(a1, a2, a3, a4, a5, a6);
williamr@2
   497
  }
williamr@2
   498
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
williamr@2
   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) {
williamr@2
   500
    return (o.*func)(a1, a2, a3, a4, a5, a6);
williamr@2
   501
  }
williamr@2
   502
};
williamr@2
   503
williamr@2
   504
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
williamr@2
   505
struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
williamr@2
   506
williamr@2
   507
  template<class T> struct sig { typedef Result type; };
williamr@2
   508
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
williamr@2
   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) {
williamr@2
   510
    return func(a1, a2, a3, a4, a5, a6, a7);
williamr@2
   511
  }
williamr@2
   512
};
williamr@2
   513
williamr@2
   514
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
williamr@2
   515
struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
williamr@2
   516
williamr@2
   517
  template<class T> struct sig { typedef Result type; };
williamr@2
   518
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
williamr@2
   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) {
williamr@2
   520
    return func(a1, a2, a3, a4, a5, a6, a7);
williamr@2
   521
  }
williamr@2
   522
};
williamr@2
   523
williamr@2
   524
williamr@2
   525
// -- function adaptors with 9 argument apply
williamr@2
   526
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
williamr@2
   527
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const> {
williamr@2
   528
williamr@2
   529
  template<class T> struct sig { typedef Result type; };
williamr@2
   530
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
williamr@2
   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) {
williamr@2
   532
    return (o->*func)(a1, a2, a3, a4, a5, a6, a7);
williamr@2
   533
  }
williamr@2
   534
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
williamr@2
   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) {
williamr@2
   536
    return (o.*func)(a1, a2, a3, a4, a5, a6, a7);
williamr@2
   537
  }
williamr@2
   538
};
williamr@2
   539
williamr@2
   540
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
williamr@2
   541
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
williamr@2
   542
williamr@2
   543
  template<class T> struct sig { typedef Result type; };
williamr@2
   544
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
williamr@2
   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) {
williamr@2
   546
    return (o->*func)(a1, a2, a3, a4, a5, a6, a7);
williamr@2
   547
  }
williamr@2
   548
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
williamr@2
   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) {
williamr@2
   550
    return (o.*func)(a1, a2, a3, a4, a5, a6, a7);
williamr@2
   551
  }
williamr@2
   552
};
williamr@2
   553
williamr@2
   554
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
williamr@2
   555
struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
williamr@2
   556
williamr@2
   557
  template<class T> struct sig { typedef Result type; };
williamr@2
   558
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
williamr@2
   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) {
williamr@2
   560
    return func(a1, a2, a3, a4, a5, a6, a7, a8);
williamr@2
   561
  }
williamr@2
   562
};
williamr@2
   563
williamr@2
   564
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
williamr@2
   565
struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
williamr@2
   566
williamr@2
   567
  template<class T> struct sig { typedef Result type; };
williamr@2
   568
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
williamr@2
   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) {
williamr@2
   570
    return func(a1, a2, a3, a4, a5, a6, a7, a8);
williamr@2
   571
  }
williamr@2
   572
};
williamr@2
   573
williamr@2
   574
williamr@2
   575
// -- function adaptors with 10 argument apply
williamr@2
   576
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
williamr@2
   577
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const> {
williamr@2
   578
williamr@2
   579
  template<class T> struct sig { typedef Result type; };
williamr@2
   580
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
williamr@2
   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) {
williamr@2
   582
    return (o->*func)(a1, a2, a3, a4, a5, a6, a7, a8);
williamr@2
   583
  }
williamr@2
   584
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
williamr@2
   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) {
williamr@2
   586
    return (o.*func)(a1, a2, a3, a4, a5, a6, a7, a8);
williamr@2
   587
  }
williamr@2
   588
};
williamr@2
   589
williamr@2
   590
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
williamr@2
   591
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
williamr@2
   592
williamr@2
   593
  template<class T> struct sig { typedef Result type; };
williamr@2
   594
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
williamr@2
   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) {
williamr@2
   596
    return (o->*func)(a1, a2, a3, a4, a5, a6, a7, a8);
williamr@2
   597
  }
williamr@2
   598
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
williamr@2
   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) {
williamr@2
   600
    return (o.*func)(a1, a2, a3, a4, a5, a6, a7, a8);
williamr@2
   601
  }
williamr@2
   602
};
williamr@2
   603
williamr@2
   604
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result>
williamr@2
   605
struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {
williamr@2
   606
williamr@2
   607
  template<class T> struct sig { typedef Result type; };
williamr@2
   608
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
williamr@2
   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) {
williamr@2
   610
    return func(a1, a2, a3, a4, a5, a6, a7, a8, a9);
williamr@2
   611
  }
williamr@2
   612
};
williamr@2
   613
williamr@2
   614
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result>
williamr@2
   615
struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {
williamr@2
   616
williamr@2
   617
  template<class T> struct sig { typedef Result type; };
williamr@2
   618
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
williamr@2
   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) {
williamr@2
   620
    return func(a1, a2, a3, a4, a5, a6, a7, a8, a9);
williamr@2
   621
  }
williamr@2
   622
};
williamr@2
   623
williamr@2
   624
} // namespace lambda
williamr@2
   625
} // namespace boost
williamr@2
   626
williamr@2
   627
#endif
williamr@2
   628
williamr@2
   629
williamr@2
   630
williamr@2
   631
williamr@2
   632
williamr@2
   633
williamr@2
   634
williamr@2
   635
williamr@2
   636
williamr@2
   637
williamr@2
   638
williamr@2
   639
williamr@2
   640