← Back to branch summary

~ubuntu-branches/ubuntu/wily/ruby-passenger/wily-proposed

« back to all changes in this revision

Viewing changes to ext/boost/lambda/detail/function_adaptors.hpp

  • Committer: Package Import Robot
  • Author(s): Felix Geyer
  • Date: 2013-11-23 23:50:02 UTC
  • mfrom: (1.1.4)
  • Revision ID: package-import@ubuntu.com-20131123235002-8fdhsq7afj15o2z2
Tags: 4.0.25-1
http://bugs.debian.org/725591
* New upstream release.
* Refresh fix_install_path.patch.
* Build for Ruby 2.0 instead of 1.8. (Closes: #725591)
* Add fix_ftbfs_fortify_source.patch.
* Install passenger template files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ext/boost/lambda/detail/function_adaptors.hpp
1
 
// Boost Lambda Library -  function_adaptors.hpp ----------------------------
2
 
 
3
 
// Copyright (C) 1999, 2000 Jaakko Jarvi (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/mpl/has_xxx.hpp"
16
 
#include "boost/tuple/tuple.hpp"
17
 
#include "boost/type_traits/same_traits.hpp"
18
 
#include "boost/type_traits/remove_reference.hpp"
19
 
#include "boost/type_traits/remove_cv.hpp"
20
 
#include "boost/type_traits/add_const.hpp"
21
 
#include "boost/type_traits/add_volatile.hpp"
22
 
#include "boost/utility/result_of.hpp"
23
 
 
24
 
namespace boost { 
25
 
namespace lambda {
26
 
 
27
 
namespace detail {
28
 
 
29
 
BOOST_MPL_HAS_XXX_TEMPLATE_DEF(sig)
30
 
 
31
 
template<class Tuple>
32
 
struct remove_references_from_elements {
33
 
  typedef typename boost::tuples::cons<
34
 
    typename boost::remove_reference<typename Tuple::head_type>::type,
35
 
    typename remove_references_from_elements<typename Tuple::tail_type>::type
36
 
  > type;
37
 
};
38
 
 
39
 
template<>
40
 
struct remove_references_from_elements<boost::tuples::null_type> {
41
 
  typedef boost::tuples::null_type type;
42
 
};
43
 
 
44
 
}
45
 
 
46
 
template <class Func> struct function_adaptor {
47
 
 
48
 
  typedef typename detail::remove_reference_and_cv<Func>::type plainF;
49
 
 
50
 
#if !defined(BOOST_NO_RESULT_OF)
51
 
  // Support functors that use the boost::result_of return type convention.
52
 
  template<class Tuple, int Length, bool HasSig>
53
 
  struct result_converter;
54
 
  template<class Tuple, int Length>
55
 
  struct result_converter<Tuple, Length, true>
56
 
    : plainF::template sig<
57
 
        typename detail::remove_references_from_elements<Tuple>::type
58
 
      >
59
 
  {};
60
 
  template<class Tuple>
61
 
  struct result_converter<Tuple, 0, false>
62
 
    : result_of<plainF()>
63
 
  {};
64
 
  template<class Tuple>
65
 
  struct result_converter<Tuple, 1, false>
66
 
    : result_of<plainF(
67
 
        typename tuples::element<1, Tuple>::type)
68
 
      >
69
 
  {};
70
 
  template<class Tuple>
71
 
  struct result_converter<Tuple, 2, false>
72
 
    : result_of<plainF(
73
 
        typename tuples::element<1, Tuple>::type,
74
 
        typename tuples::element<2, Tuple>::type)
75
 
      >
76
 
  {};
77
 
  template<class Tuple>
78
 
  struct result_converter<Tuple, 3, false>
79
 
    : result_of<plainF(
80
 
        typename tuples::element<1, Tuple>::type,
81
 
        typename tuples::element<2, Tuple>::type,
82
 
        typename tuples::element<3, Tuple>::type)
83
 
      >
84
 
  {};
85
 
  template<class Tuple>
86
 
  struct result_converter<Tuple, 4, false>
87
 
    : result_of<plainF(
88
 
        typename tuples::element<1, Tuple>::type,
89
 
        typename tuples::element<2, Tuple>::type,
90
 
        typename tuples::element<3, Tuple>::type,
91
 
        typename tuples::element<4, Tuple>::type)
92
 
      >
93
 
  {};
94
 
  template<class Tuple>
95
 
  struct result_converter<Tuple, 5, false>
96
 
    : result_of<plainF(
97
 
        typename tuples::element<1, Tuple>::type,
98
 
        typename tuples::element<2, Tuple>::type,
99
 
        typename tuples::element<3, Tuple>::type,
100
 
        typename tuples::element<4, Tuple>::type,
101
 
        typename tuples::element<5, Tuple>::type)
102
 
      >
103
 
  {};
104
 
  template<class Tuple>
105
 
  struct result_converter<Tuple, 6, false>
106
 
    : result_of<plainF(
107
 
        typename tuples::element<1, Tuple>::type,
108
 
        typename tuples::element<2, Tuple>::type,
109
 
        typename tuples::element<3, Tuple>::type,
110
 
        typename tuples::element<4, Tuple>::type,
111
 
        typename tuples::element<5, Tuple>::type,
112
 
        typename tuples::element<6, Tuple>::type)
113
 
      >
114
 
  {};
115
 
  template<class Tuple>
116
 
  struct result_converter<Tuple, 7, false>
117
 
    : result_of<plainF(
118
 
        typename tuples::element<1, Tuple>::type,
119
 
        typename tuples::element<2, Tuple>::type,
120
 
        typename tuples::element<3, Tuple>::type,
121
 
        typename tuples::element<4, Tuple>::type,
122
 
        typename tuples::element<5, Tuple>::type,
123
 
        typename tuples::element<6, Tuple>::type,
124
 
        typename tuples::element<7, Tuple>::type)
125
 
      >
126
 
  {};
127
 
  template<class Tuple>
128
 
  struct result_converter<Tuple, 8, false>
129
 
    : result_of<plainF(
130
 
        typename tuples::element<1, Tuple>::type,
131
 
        typename tuples::element<2, Tuple>::type,
132
 
        typename tuples::element<3, Tuple>::type,
133
 
        typename tuples::element<4, Tuple>::type,
134
 
        typename tuples::element<5, Tuple>::type,
135
 
        typename tuples::element<6, Tuple>::type,
136
 
        typename tuples::element<7, Tuple>::type,
137
 
        typename tuples::element<8, Tuple>::type)
138
 
      >
139
 
  {};
140
 
  template<class Tuple>
141
 
  struct result_converter<Tuple, 9, false>
142
 
    : result_of<plainF(
143
 
        typename tuples::element<1, Tuple>::type,
144
 
        typename tuples::element<2, Tuple>::type,
145
 
        typename tuples::element<3, Tuple>::type,
146
 
        typename tuples::element<4, Tuple>::type,
147
 
        typename tuples::element<5, Tuple>::type,
148
 
        typename tuples::element<6, Tuple>::type,
149
 
        typename tuples::element<7, Tuple>::type,
150
 
        typename tuples::element<8, Tuple>::type,
151
 
        typename tuples::element<9, Tuple>::type)
152
 
      >
153
 
  {};
154
 
 
155
 
  // we do not know the return type off-hand, we must ask it from Func
156
 
  // To sig we pass a cons list, where the head is the function object type
157
 
  // itself (potentially cv-qualified)
158
 
  // and the tail contains the types of the actual arguments to be passed
159
 
  // to the function object. The arguments can be cv qualified
160
 
  // as well.
161
 
  template <class Args>
162
 
  struct sig
163
 
    : result_converter<
164
 
        Args
165
 
      , tuples::length<typename Args::tail_type>::value
166
 
      , detail::has_sig<plainF>::value
167
 
      >
168
 
  {};
169
 
#else // BOOST_NO_RESULT_OF
170
 
 
171
 
  template <class Args> class sig {
172
 
    typedef typename detail::remove_reference_and_cv<Func>::type plainF;
173
 
  public:
174
 
    typedef typename plainF::template sig<
175
 
      typename detail::remove_references_from_elements<Args>::type
176
 
    >::type type;
177
 
  };
178
 
#endif
179
 
 
180
 
  template<class RET, class A1>
181
 
  static RET apply(A1& a1) {
182
 
    return a1();
183
 
  }
184
 
  template<class RET, class A1, class A2>
185
 
  static RET apply(A1& a1, A2& a2) {
186
 
    return a1(a2);
187
 
  }
188
 
  template<class RET, class A1, class A2, class A3>
189
 
  static RET apply(A1& a1, A2& a2, A3& a3) {
190
 
    return a1(a2, a3);
191
 
  }
192
 
  template<class RET, class A1, class A2, class A3, class A4>
193
 
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4) {
194
 
    return a1(a2, a3, a4);
195
 
  }
196
 
  template<class RET, class A1, class A2, class A3, class A4, class A5>
197
 
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
198
 
    return a1(a2, a3, a4, a5);
199
 
  }
200
 
  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6>
201
 
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
202
 
    return a1(a2, a3, a4, a5, a6);
203
 
  }
204
 
  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
205
 
           class A7>
206
 
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
207
 
                           A7& a7) {
208
 
    return a1(a2, a3, a4, a5, a6, a7);
209
 
  }
210
 
  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
211
 
           class A7, class A8>
212
 
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
213
 
                           A7& a7, A8& a8) {
214
 
    return a1(a2, a3, a4, a5, a6, a7, a8);
215
 
  }
216
 
  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
217
 
           class A7, class A8, class A9>
218
 
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
219
 
                           A7& a7, A8& a8, A9& a9) {
220
 
    return a1(a2, a3, a4, a5, a6, a7, a8, a9);
221
 
  }
222
 
  template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
223
 
           class A7, class A8, class A9, class A10>
224
 
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
225
 
                           A7& a7, A8& a8, A9& a9, A10& a10) {
226
 
    return a1(a2, a3, a4, a5, a6, a7, a8, a9, a10);
227
 
  }
228
 
};
229
 
 
230
 
template <class Func> struct function_adaptor<const Func>; // error 
231
 
 
232
 
// -- function adaptors with data member access
233
 
template <class Object, class T>
234
 
struct function_adaptor<T Object::*> {
235
 
 
236
 
  //  typedef detail::unspecified type;
237
 
 
238
 
  // T can have qualifiers and can be a reference type
239
 
  // We get the return type by adding const, if the object through which
240
 
  // the data member is accessed is const, and finally adding a reference
241
 
  template<class Args> class sig { 
242
 
    typedef typename boost::tuples::element<1, Args>::type argument_type;
243
 
    typedef typename boost::remove_reference<
244
 
      argument_type
245
 
    >::type unref_type;
246
 
 
247
 
    typedef typename detail::IF<boost::is_const<unref_type>::value,
248
 
      typename boost::add_const<T>::type,
249
 
      T
250
 
    >::RET properly_consted_return_type;
251
 
 
252
 
    typedef typename detail::IF<boost::is_volatile<unref_type>::value,
253
 
      typename boost::add_volatile<properly_consted_return_type>::type,
254
 
      properly_consted_return_type
255
 
    >::RET properly_cvd_return_type;
256
 
 
257
 
 
258
 
  public:
259
 
    typedef typename detail::IF<boost::is_reference<argument_type>::value,
260
 
      typename boost::add_reference<properly_cvd_return_type>::type,
261
 
      typename boost::remove_cv<T>::type
262
 
    >::RET type;
263
 
  };
264
 
 
265
 
  template <class RET>
266
 
  static RET apply( T Object::*data, Object& o) {
267
 
    return o.*data;
268
 
  }
269
 
  template <class RET>
270
 
  static RET apply( T Object::*data, const Object& o) {
271
 
    return o.*data;
272
 
  }
273
 
  template <class RET>
274
 
  static RET apply( T Object::*data, volatile Object& o) {
275
 
    return o.*data;
276
 
  }
277
 
  template <class RET>
278
 
  static RET apply( T Object::*data, const volatile Object& o) {
279
 
    return o.*data;
280
 
  }
281
 
  template <class RET>
282
 
  static RET apply( T Object::*data, Object* o) {
283
 
    return o->*data;
284
 
  }
285
 
  template <class RET>
286
 
  static RET apply( T Object::*data, const Object* o) {
287
 
    return o->*data;
288
 
  }
289
 
  template <class RET>
290
 
  static RET apply( T Object::*data, volatile Object* o) {
291
 
    return o->*data;
292
 
  }
293
 
  template <class RET>
294
 
  static RET apply( T Object::*data, const volatile Object* o) {
295
 
    return o->*data;
296
 
  }
297
 
};
298
 
 
299
 
// -- function adaptors with 1 argument apply
300
 
   
301
 
template <class Result>
302
 
struct function_adaptor<Result (void)> {
303
 
  
304
 
  template<class T> struct sig { typedef Result type; };
305
 
  template <class RET>
306
 
  static Result apply(Result (*func)()) {
307
 
    return func();
308
 
  }
309
 
};
310
 
 
311
 
template <class Result>
312
 
struct function_adaptor<Result (*)(void)> {
313
 
 
314
 
  template<class T> struct sig { typedef Result type; };
315
 
  template <class RET>
316
 
  static Result apply(Result (*func)()) {
317
 
    return func();
318
 
  }
319
 
};
320
 
 
321
 
 
322
 
// -- function adaptors with 2 argument apply
323
 
template <class Object, class Result>
324
 
struct function_adaptor<Result (Object::*)() const> {
325
 
 
326
 
  template<class T> struct sig { typedef Result type; };
327
 
  template <class RET>
328
 
  static Result apply( Result (Object::*func)() const, const Object* o) {
329
 
    return (o->*func)();
330
 
  }
331
 
  template <class RET>
332
 
  static Result apply( Result (Object::*func)() const, const Object& o) {
333
 
    return (o.*func)();
334
 
  }
335
 
};
336
 
 
337
 
template <class Object, class Result>
338
 
struct function_adaptor<Result (Object::*)()> {
339
 
 
340
 
  template<class T> struct sig { typedef Result type; };
341
 
  template <class RET>
342
 
  static Result apply( Result (Object::*func)(), Object* o) {
343
 
    return (o->*func)();
344
 
  }
345
 
  template <class RET>
346
 
  static Result apply( Result (Object::*func)(), Object& o) {
347
 
    return (o.*func)();
348
 
  }
349
 
};
350
 
 
351
 
template <class Arg1, class Result>
352
 
struct function_adaptor<Result (Arg1)> {
353
 
 
354
 
  template<class T> struct sig { typedef Result type; };
355
 
  template <class RET, class A1>
356
 
  static Result apply(Result (*func)(Arg1), A1& a1) {
357
 
    return func(a1);
358
 
  }
359
 
};
360
 
 
361
 
template <class Arg1, class Result>
362
 
struct function_adaptor<Result (*)(Arg1)> {
363
 
 
364
 
  template<class T> struct sig { typedef Result type; };
365
 
  template <class RET, class A1>
366
 
  static Result apply(Result (*func)(Arg1), A1& a1) {
367
 
    return func(a1);
368
 
  }
369
 
};
370
 
 
371
 
 
372
 
// -- function adaptors with 3 argument apply
373
 
template <class Object, class Arg1, class Result>
374
 
struct function_adaptor<Result (Object::*)(Arg1) const> {
375
 
 
376
 
  template<class T> struct sig { typedef Result type; };
377
 
  template <class RET, class A1>
378
 
  static Result apply( Result (Object::*func)(Arg1) const, const Object* o, 
379
 
    A1& a1) {
380
 
    return (o->*func)(a1);
381
 
  }
382
 
  template <class RET, class A1>
383
 
  static Result apply( Result (Object::*func)(Arg1) const, const Object& o, 
384
 
    A1& a1) {
385
 
    return (o.*func)(a1);
386
 
  }
387
 
};
388
 
 
389
 
template <class Object, class Arg1, class Result>
390
 
struct function_adaptor<Result (Object::*)(Arg1)> {
391
 
 
392
 
  template<class T> struct sig { typedef Result type; };
393
 
  template <class RET, class A1>
394
 
  static Result apply( Result (Object::*func)(Arg1), Object* o, A1& a1) {
395
 
    return (o->*func)(a1);
396
 
  }
397
 
  template <class RET, class A1>
398
 
  static Result apply( Result (Object::*func)(Arg1), Object& o, A1& a1) {
399
 
    return (o.*func)(a1);
400
 
  }
401
 
};
402
 
 
403
 
template <class Arg1, class Arg2, class Result>
404
 
struct function_adaptor<Result (Arg1, Arg2)> {
405
 
 
406
 
  template<class T> struct sig { typedef Result type; };
407
 
  template <class RET, class A1, class A2>
408
 
  static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) {
409
 
    return func(a1, a2);
410
 
  }
411
 
};
412
 
 
413
 
template <class Arg1, class Arg2, class Result>
414
 
struct function_adaptor<Result (*)(Arg1, Arg2)> {
415
 
 
416
 
  template<class T> struct sig { typedef Result type; };
417
 
  template <class RET, class A1, class A2>
418
 
  static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) {
419
 
    return func(a1, a2);
420
 
  }
421
 
};
422
 
 
423
 
 
424
 
// -- function adaptors with 4 argument apply
425
 
template <class Object, class Arg1, class Arg2, class Result>
426
 
struct function_adaptor<Result (Object::*)(Arg1, Arg2) const> {
427
 
 
428
 
  template<class T> struct sig { typedef Result type; };
429
 
  template <class RET, class A1, class A2>
430
 
  static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object* o, A1& a1, A2& a2) {
431
 
    return (o->*func)(a1, a2);
432
 
  }
433
 
  template <class RET, class A1, class A2>
434
 
  static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object& o, A1& a1, A2& a2) {
435
 
    return (o.*func)(a1, a2);
436
 
  }
437
 
};
438
 
 
439
 
template <class Object, class Arg1, class Arg2, class Result>
440
 
struct function_adaptor<Result (Object::*)(Arg1, Arg2)> {
441
 
 
442
 
  template<class T> struct sig { typedef Result type; };
443
 
  template <class RET, class A1, class A2>
444
 
  static Result apply( Result (Object::*func)(Arg1, Arg2), Object* o, A1& a1, A2& a2) {
445
 
    return (o->*func)(a1, a2);
446
 
  }
447
 
  template <class RET, class A1, class A2>
448
 
  static Result apply( Result (Object::*func)(Arg1, Arg2), Object& o, A1& a1, A2& a2) {
449
 
    return (o.*func)(a1, a2);
450
 
  }
451
 
};
452
 
 
453
 
template <class Arg1, class Arg2, class Arg3, class Result>
454
 
struct function_adaptor<Result (Arg1, Arg2, Arg3)> {
455
 
 
456
 
  template<class T> struct sig { typedef Result type; };
457
 
  template <class RET, class A1, class A2, class A3>
458
 
  static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) {
459
 
    return func(a1, a2, a3);
460
 
  }
461
 
};
462
 
 
463
 
template <class Arg1, class Arg2, class Arg3, class Result>
464
 
struct function_adaptor<Result (*)(Arg1, Arg2, Arg3)> {
465
 
 
466
 
  template<class T> struct sig { typedef Result type; };
467
 
  template <class RET, class A1, class A2, class A3>
468
 
  static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) {
469
 
    return func(a1, a2, a3);
470
 
  }
471
 
};
472
 
 
473
 
 
474
 
// -- function adaptors with 5 argument apply
475
 
template <class Object, class Arg1, class Arg2, class Arg3, class Result>
476
 
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3) const> {
477
 
 
478
 
  template<class T> struct sig { typedef Result type; };
479
 
  template <class RET, class A1, class A2, class A3>
480
 
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object* o, A1& a1, A2& a2, A3& a3) {
481
 
    return (o->*func)(a1, a2, a3);
482
 
  }
483
 
  template <class RET, class A1, class A2, class A3>
484
 
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object& o, A1& a1, A2& a2, A3& a3) {
485
 
    return (o.*func)(a1, a2, a3);
486
 
  }
487
 
};
488
 
 
489
 
template <class Object, class Arg1, class Arg2, class Arg3, class Result>
490
 
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3)> {
491
 
 
492
 
  template<class T> struct sig { typedef Result type; };
493
 
  template <class RET, class A1, class A2, class A3>
494
 
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object* o, A1& a1, A2& a2, A3& a3) {
495
 
    return (o->*func)(a1, a2, a3);
496
 
  }
497
 
  template <class RET, class A1, class A2, class A3>
498
 
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object& o, A1& a1, A2& a2, A3& a3) {
499
 
    return (o.*func)(a1, a2, a3);
500
 
  }
501
 
};
502
 
 
503
 
template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>
504
 
struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4)> {
505
 
 
506
 
  template<class T> struct sig { typedef Result type; };
507
 
  template <class RET, class A1, class A2, class A3, class A4>
508
 
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) {
509
 
    return func(a1, a2, a3, a4);
510
 
  }
511
 
};
512
 
 
513
 
template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>
514
 
struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4)> {
515
 
 
516
 
  template<class T> struct sig { typedef Result type; };
517
 
  template <class RET, class A1, class A2, class A3, class A4>
518
 
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) {
519
 
    return func(a1, a2, a3, a4);
520
 
  }
521
 
};
522
 
 
523
 
 
524
 
// -- function adaptors with 6 argument apply
525
 
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>
526
 
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4) const> {
527
 
 
528
 
  template<class T> struct sig { typedef Result type; };
529
 
  template <class RET, class A1, class A2, class A3, class A4>
530
 
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4) {
531
 
    return (o->*func)(a1, a2, a3, a4);
532
 
  }
533
 
  template <class RET, class A1, class A2, class A3, class A4>
534
 
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4) {
535
 
    return (o.*func)(a1, a2, a3, a4);
536
 
  }
537
 
};
538
 
 
539
 
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>
540
 
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4)> {
541
 
 
542
 
  template<class T> struct sig { typedef Result type; };
543
 
  template <class RET, class A1, class A2, class A3, class A4>
544
 
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object* o, A1& a1, A2& a2, A3& a3, A4& a4) {
545
 
    return (o->*func)(a1, a2, a3, a4);
546
 
  }
547
 
  template <class RET, class A1, class A2, class A3, class A4>
548
 
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object& o, A1& a1, A2& a2, A3& a3, A4& a4) {
549
 
    return (o.*func)(a1, a2, a3, a4);
550
 
  }
551
 
};
552
 
 
553
 
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
554
 
struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5)> {
555
 
 
556
 
  template<class T> struct sig { typedef Result type; };
557
 
  template <class RET, class A1, class A2, class A3, class A4, class A5>
558
 
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
559
 
    return func(a1, a2, a3, a4, a5);
560
 
  }
561
 
};
562
 
 
563
 
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
564
 
struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {
565
 
 
566
 
  template<class T> struct sig { typedef Result type; };
567
 
  template <class RET, class A1, class A2, class A3, class A4, class A5>
568
 
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
569
 
    return func(a1, a2, a3, a4, a5);
570
 
  }
571
 
};
572
 
 
573
 
 
574
 
// -- function adaptors with 7 argument apply
575
 
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
576
 
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5) const> {
577
 
 
578
 
  template<class T> struct sig { typedef Result type; };
579
 
  template <class RET, class A1, class A2, class A3, class A4, class A5>
580
 
  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) {
581
 
    return (o->*func)(a1, a2, a3, a4, a5);
582
 
  }
583
 
  template <class RET, class A1, class A2, class A3, class A4, class A5>
584
 
  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) {
585
 
    return (o.*func)(a1, a2, a3, a4, a5);
586
 
  }
587
 
};
588
 
 
589
 
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
590
 
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {
591
 
 
592
 
  template<class T> struct sig { typedef Result type; };
593
 
  template <class RET, class A1, class A2, class A3, class A4, class A5>
594
 
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
595
 
    return (o->*func)(a1, a2, a3, a4, a5);
596
 
  }
597
 
  template <class RET, class A1, class A2, class A3, class A4, class A5>
598
 
  static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
599
 
    return (o.*func)(a1, a2, a3, a4, a5);
600
 
  }
601
 
};
602
 
 
603
 
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
604
 
struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
605
 
 
606
 
  template<class T> struct sig { typedef Result type; };
607
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
608
 
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
609
 
    return func(a1, a2, a3, a4, a5, a6);
610
 
  }
611
 
};
612
 
 
613
 
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
614
 
struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
615
 
 
616
 
  template<class T> struct sig { typedef Result type; };
617
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
618
 
  static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
619
 
    return func(a1, a2, a3, a4, a5, a6);
620
 
  }
621
 
};
622
 
 
623
 
 
624
 
// -- function adaptors with 8 argument apply
625
 
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
626
 
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const> {
627
 
 
628
 
  template<class T> struct sig { typedef Result type; };
629
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
630
 
  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) {
631
 
    return (o->*func)(a1, a2, a3, a4, a5, a6);
632
 
  }
633
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
634
 
  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) {
635
 
    return (o.*func)(a1, a2, a3, a4, a5, a6);
636
 
  }
637
 
};
638
 
 
639
 
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
640
 
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
641
 
 
642
 
  template<class T> struct sig { typedef Result type; };
643
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
644
 
  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) {
645
 
    return (o->*func)(a1, a2, a3, a4, a5, a6);
646
 
  }
647
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
648
 
  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) {
649
 
    return (o.*func)(a1, a2, a3, a4, a5, a6);
650
 
  }
651
 
};
652
 
 
653
 
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
654
 
struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
655
 
 
656
 
  template<class T> struct sig { typedef Result type; };
657
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
658
 
  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) {
659
 
    return func(a1, a2, a3, a4, a5, a6, a7);
660
 
  }
661
 
};
662
 
 
663
 
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
664
 
struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
665
 
 
666
 
  template<class T> struct sig { typedef Result type; };
667
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
668
 
  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) {
669
 
    return func(a1, a2, a3, a4, a5, a6, a7);
670
 
  }
671
 
};
672
 
 
673
 
 
674
 
// -- function adaptors with 9 argument apply
675
 
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
676
 
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const> {
677
 
 
678
 
  template<class T> struct sig { typedef Result type; };
679
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
680
 
  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) {
681
 
    return (o->*func)(a1, a2, a3, a4, a5, a6, a7);
682
 
  }
683
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
684
 
  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) {
685
 
    return (o.*func)(a1, a2, a3, a4, a5, a6, a7);
686
 
  }
687
 
};
688
 
 
689
 
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
690
 
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
691
 
 
692
 
  template<class T> struct sig { typedef Result type; };
693
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
694
 
  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) {
695
 
    return (o->*func)(a1, a2, a3, a4, a5, a6, a7);
696
 
  }
697
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
698
 
  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) {
699
 
    return (o.*func)(a1, a2, a3, a4, a5, a6, a7);
700
 
  }
701
 
};
702
 
 
703
 
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
704
 
struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
705
 
 
706
 
  template<class T> struct sig { typedef Result type; };
707
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
708
 
  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) {
709
 
    return func(a1, a2, a3, a4, a5, a6, a7, a8);
710
 
  }
711
 
};
712
 
 
713
 
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
714
 
struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
715
 
 
716
 
  template<class T> struct sig { typedef Result type; };
717
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
718
 
  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) {
719
 
    return func(a1, a2, a3, a4, a5, a6, a7, a8);
720
 
  }
721
 
};
722
 
 
723
 
 
724
 
// -- function adaptors with 10 argument apply
725
 
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
726
 
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const> {
727
 
 
728
 
  template<class T> struct sig { typedef Result type; };
729
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
730
 
  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) {
731
 
    return (o->*func)(a1, a2, a3, a4, a5, a6, a7, a8);
732
 
  }
733
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
734
 
  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) {
735
 
    return (o.*func)(a1, a2, a3, a4, a5, a6, a7, a8);
736
 
  }
737
 
};
738
 
 
739
 
template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
740
 
struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
741
 
 
742
 
  template<class T> struct sig { typedef Result type; };
743
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
744
 
  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) {
745
 
    return (o->*func)(a1, a2, a3, a4, a5, a6, a7, a8);
746
 
  }
747
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
748
 
  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) {
749
 
    return (o.*func)(a1, a2, a3, a4, a5, a6, a7, a8);
750
 
  }
751
 
};
752
 
 
753
 
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result>
754
 
struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {
755
 
 
756
 
  template<class T> struct sig { typedef Result type; };
757
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
758
 
  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) {
759
 
    return func(a1, a2, a3, a4, a5, a6, a7, a8, a9);
760
 
  }
761
 
};
762
 
 
763
 
template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result>
764
 
struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {
765
 
 
766
 
  template<class T> struct sig { typedef Result type; };
767
 
  template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
768
 
  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) {
769
 
    return func(a1, a2, a3, a4, a5, a6, a7, a8, a9);
770
 
  }
771
 
};
772
 
 
773
 
} // namespace lambda
774
 
} // namespace boost
775
 
 
776
 
#endif
777
 
 
778
 
 
779
 
 
780
 
 
781
 
 
782
 
 
783
 
 
784
 
 
785
 
 
786
 
 
787
 
 
788
 
 
789