|
1 // -- bind_functions.hpp -- Boost Lambda Library |
|
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 http://www.boost.org |
|
10 |
|
11 // ---------------------------------------------------------------- |
|
12 |
|
13 #ifndef BOOST_LAMBDA_BIND_FUNCTIONS_HPP |
|
14 #define BOOST_LAMBDA_BIND_FUNCTIONS_HPP |
|
15 |
|
16 |
|
17 namespace boost { |
|
18 namespace lambda { |
|
19 |
|
20 #ifdef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING |
|
21 |
|
22 // gcc 2.96 instantiates bind functions it does not even call. |
|
23 // These instantiations lead to incorrect types in the return type, |
|
24 // and a compilation error results. |
|
25 // This tweaking is to prevent the formation of the erroneous type. |
|
26 namespace detail { |
|
27 |
|
28 template<class T> struct constify_non_funcs { |
|
29 typedef typename |
|
30 detail::IF_type<boost::is_function<T>::value, |
|
31 boost::add_reference<T>, |
|
32 boost::add_const<T> |
|
33 >::type type; |
|
34 }; |
|
35 |
|
36 } |
|
37 #endif |
|
38 // 1-argument bind functions -------------------------- |
|
39 #ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T |
|
40 template <class Result> |
|
41 inline const |
|
42 lambda_functor< |
|
43 lambda_functor_base< |
|
44 action<1, function_action<1, Result> >, |
|
45 typename detail::bind_tuple_mapper<Result(&)()>::type |
|
46 > |
|
47 > |
|
48 |
|
49 bind(Result(& a1)()) { |
|
50 return |
|
51 lambda_functor_base< |
|
52 action<1, function_action<1, Result> >, |
|
53 typename detail::bind_tuple_mapper<Result(&)()>::type |
|
54 > |
|
55 ( typename detail::bind_tuple_mapper<Result(&)()>::type |
|
56 (a1) |
|
57 ); |
|
58 } |
|
59 #endif |
|
60 |
|
61 #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING |
|
62 template <class Arg1> |
|
63 inline const |
|
64 lambda_functor< |
|
65 lambda_functor_base< |
|
66 action<1, function_action<1> >, |
|
67 typename detail::bind_tuple_mapper<const Arg1>::type |
|
68 > |
|
69 > |
|
70 |
|
71 bind(const Arg1& a1) { |
|
72 return |
|
73 lambda_functor_base< |
|
74 action<1, function_action<1> >, |
|
75 typename detail::bind_tuple_mapper<const Arg1>::type |
|
76 > |
|
77 ( typename detail::bind_tuple_mapper<const Arg1>::type |
|
78 (a1) |
|
79 ); |
|
80 } |
|
81 |
|
82 template <class Result, class Arg1> |
|
83 inline const |
|
84 lambda_functor< |
|
85 lambda_functor_base< |
|
86 action<1, function_action<1, Result> >, |
|
87 typename detail::bind_tuple_mapper<const Arg1>::type |
|
88 > |
|
89 > |
|
90 |
|
91 bind(const Arg1& a1) { |
|
92 return |
|
93 lambda_functor_base< |
|
94 action<1, function_action<1, Result> >, |
|
95 typename detail::bind_tuple_mapper<const Arg1>::type |
|
96 > |
|
97 ( typename detail::bind_tuple_mapper<const Arg1>::type |
|
98 (a1) |
|
99 ); |
|
100 } |
|
101 |
|
102 |
|
103 #else |
|
104 template <class Arg1> |
|
105 inline const |
|
106 lambda_functor< |
|
107 lambda_functor_base< |
|
108 action<1, function_action<1> >, |
|
109 typename detail::bind_tuple_mapper< |
|
110 typename detail::constify_non_funcs<Arg1>::type |
|
111 >::type |
|
112 > |
|
113 > |
|
114 |
|
115 bind(const Arg1& a1) { |
|
116 return |
|
117 lambda_functor_base< |
|
118 action<1, function_action<1> >, |
|
119 typename detail::bind_tuple_mapper< |
|
120 typename detail::constify_non_funcs<Arg1>::type |
|
121 >::type |
|
122 > |
|
123 ( typename detail::bind_tuple_mapper< |
|
124 typename detail::constify_non_funcs<Arg1>::type |
|
125 >::type |
|
126 (a1) |
|
127 ); |
|
128 } |
|
129 |
|
130 template <class Result, class Arg1> |
|
131 inline const |
|
132 lambda_functor< |
|
133 lambda_functor_base< |
|
134 action<1, function_action<1, Result> >, |
|
135 typename detail::bind_tuple_mapper< |
|
136 typename detail::constify_non_funcs<Arg1>::type |
|
137 >::type |
|
138 > |
|
139 > |
|
140 |
|
141 bind(const Arg1& a1) { |
|
142 return |
|
143 lambda_functor_base< |
|
144 action<1, function_action<1, Result> >, |
|
145 typename detail::bind_tuple_mapper< |
|
146 typename detail::constify_non_funcs<Arg1>::type |
|
147 >::type |
|
148 > |
|
149 ( typename detail::bind_tuple_mapper< |
|
150 typename detail::constify_non_funcs<Arg1>::type |
|
151 >::type |
|
152 (a1) |
|
153 ); |
|
154 } |
|
155 |
|
156 template <class Result> |
|
157 inline const |
|
158 lambda_functor< |
|
159 lambda_functor_base< |
|
160 action<1, function_action<1, Result> >, |
|
161 typename detail::bind_tuple_mapper<Result(*)()>::type |
|
162 > |
|
163 > |
|
164 |
|
165 bind(Result(* const & a1)()) { |
|
166 return |
|
167 lambda_functor_base< |
|
168 action<1, function_action<1, Result> >, |
|
169 typename detail::bind_tuple_mapper<Result(*)()>::type |
|
170 > |
|
171 ( typename detail::bind_tuple_mapper<Result(*)()>::type |
|
172 (a1) |
|
173 ); |
|
174 } |
|
175 |
|
176 |
|
177 #endif |
|
178 |
|
179 // 2-argument bind functions -------------------------- |
|
180 #ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T |
|
181 template <class Result, class Par1, class Arg2> |
|
182 inline const |
|
183 lambda_functor< |
|
184 lambda_functor_base< |
|
185 action<2, function_action<2, Result> >, |
|
186 typename detail::bind_tuple_mapper<Result(&)(Par1), const Arg2>::type |
|
187 > |
|
188 > |
|
189 |
|
190 bind(Result(&a1)(Par1), const Arg2& a2) { |
|
191 return |
|
192 lambda_functor_base< |
|
193 action<2, function_action<2, Result> >, |
|
194 typename detail::bind_tuple_mapper<Result(&)(Par1), const Arg2>::type |
|
195 > |
|
196 ( typename detail::bind_tuple_mapper<Result(&)(Par1), const Arg2>::type |
|
197 (a1, a2) |
|
198 ); |
|
199 } |
|
200 #endif |
|
201 |
|
202 #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING |
|
203 template <class Arg1, class Arg2> |
|
204 inline const |
|
205 lambda_functor< |
|
206 lambda_functor_base< |
|
207 action<2, function_action<2> >, |
|
208 typename detail::bind_tuple_mapper<const Arg1, const Arg2>::type |
|
209 > |
|
210 > |
|
211 |
|
212 bind(const Arg1& a1, const Arg2& a2) { |
|
213 return |
|
214 lambda_functor_base< |
|
215 action<2, function_action<2> >, |
|
216 typename detail::bind_tuple_mapper<const Arg1, const Arg2>::type |
|
217 > |
|
218 ( typename detail::bind_tuple_mapper<const Arg1, const Arg2>::type |
|
219 (a1, a2) |
|
220 ); |
|
221 } |
|
222 |
|
223 template <class Result, class Arg1, class Arg2> |
|
224 inline const |
|
225 lambda_functor< |
|
226 lambda_functor_base< |
|
227 action<2, function_action<2, Result> >, |
|
228 typename detail::bind_tuple_mapper<const Arg1, const Arg2>::type |
|
229 > |
|
230 > |
|
231 |
|
232 bind(const Arg1& a1, const Arg2& a2) { |
|
233 return |
|
234 lambda_functor_base< |
|
235 action<2, function_action<2, Result> >, |
|
236 typename detail::bind_tuple_mapper<const Arg1, const Arg2>::type |
|
237 > |
|
238 ( typename detail::bind_tuple_mapper<const Arg1, const Arg2>::type |
|
239 (a1, a2) |
|
240 ); |
|
241 } |
|
242 |
|
243 |
|
244 #else |
|
245 template <class Arg1, class Arg2> |
|
246 inline const |
|
247 lambda_functor< |
|
248 lambda_functor_base< |
|
249 action<2, function_action<2> >, |
|
250 typename detail::bind_tuple_mapper< |
|
251 typename detail::constify_non_funcs<Arg1>::type, const Arg2 |
|
252 >::type |
|
253 > |
|
254 > |
|
255 |
|
256 bind(const Arg1& a1, const Arg2& a2) { |
|
257 return |
|
258 lambda_functor_base< |
|
259 action<2, function_action<2> >, |
|
260 typename detail::bind_tuple_mapper< |
|
261 typename detail::constify_non_funcs<Arg1>::type, const Arg2 |
|
262 >::type |
|
263 > |
|
264 ( typename detail::bind_tuple_mapper< |
|
265 typename detail::constify_non_funcs<Arg1>::type, const Arg2 |
|
266 >::type |
|
267 (a1, a2) |
|
268 ); |
|
269 } |
|
270 |
|
271 template <class Result, class Arg1, class Arg2> |
|
272 inline const |
|
273 lambda_functor< |
|
274 lambda_functor_base< |
|
275 action<2, function_action<2, Result> >, |
|
276 typename detail::bind_tuple_mapper< |
|
277 typename detail::constify_non_funcs<Arg1>::type, const Arg2 |
|
278 >::type |
|
279 > |
|
280 > |
|
281 |
|
282 bind(const Arg1& a1, const Arg2& a2) { |
|
283 return |
|
284 lambda_functor_base< |
|
285 action<2, function_action<2, Result> >, |
|
286 typename detail::bind_tuple_mapper< |
|
287 typename detail::constify_non_funcs<Arg1>::type, const Arg2 |
|
288 >::type |
|
289 > |
|
290 ( typename detail::bind_tuple_mapper< |
|
291 typename detail::constify_non_funcs<Arg1>::type, const Arg2 |
|
292 >::type |
|
293 (a1, a2) |
|
294 ); |
|
295 } |
|
296 |
|
297 template <class Result, class Par1, class Arg2> |
|
298 inline const |
|
299 lambda_functor< |
|
300 lambda_functor_base< |
|
301 action<2, function_action<2, Result> >, |
|
302 typename detail::bind_tuple_mapper<Result(*)(Par1), const Arg2>::type |
|
303 > |
|
304 > |
|
305 |
|
306 bind(Result(* const & a1)(Par1), const Arg2& a2) { |
|
307 return |
|
308 lambda_functor_base< |
|
309 action<2, function_action<2, Result> >, |
|
310 typename detail::bind_tuple_mapper<Result(*)(Par1), const Arg2>::type |
|
311 > |
|
312 ( typename detail::bind_tuple_mapper<Result(*)(Par1), const Arg2>::type |
|
313 (a1, a2) |
|
314 ); |
|
315 } |
|
316 |
|
317 |
|
318 #endif |
|
319 |
|
320 // 3-argument bind functions -------------------------- |
|
321 #ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T |
|
322 template <class Result, class Par1, class Par2, class Arg2, class Arg3> |
|
323 inline const |
|
324 lambda_functor< |
|
325 lambda_functor_base< |
|
326 action<3, function_action<3, Result> >, |
|
327 typename detail::bind_tuple_mapper< |
|
328 Result(&)(Par1, Par2), const Arg2, const Arg3 |
|
329 >::type |
|
330 > |
|
331 > |
|
332 |
|
333 bind(Result(&a1)(Par1, Par2), const Arg2& a2, const Arg3& a3) { |
|
334 return |
|
335 lambda_functor_base< |
|
336 action<3, function_action<3, Result> >, |
|
337 typename detail::bind_tuple_mapper< |
|
338 Result(&)(Par1, Par2), const Arg2, const Arg3 |
|
339 >::type |
|
340 > |
|
341 ( typename detail::bind_tuple_mapper< |
|
342 Result(&)(Par1, Par2), const Arg2, const Arg3 |
|
343 >::type |
|
344 (a1, a2, a3) |
|
345 ); |
|
346 } |
|
347 #endif |
|
348 |
|
349 #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING |
|
350 template <class Arg1, class Arg2, class Arg3> |
|
351 inline const |
|
352 lambda_functor< |
|
353 lambda_functor_base< |
|
354 action<3, function_action<3> >, |
|
355 typename detail::bind_tuple_mapper< |
|
356 const Arg1, const Arg2, const Arg3 |
|
357 >::type |
|
358 > |
|
359 > |
|
360 |
|
361 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3) { |
|
362 return |
|
363 lambda_functor_base< |
|
364 action<3, function_action<3> >, |
|
365 typename detail::bind_tuple_mapper< |
|
366 const Arg1, const Arg2, const Arg3 |
|
367 >::type |
|
368 > |
|
369 ( typename detail::bind_tuple_mapper< |
|
370 const Arg1, const Arg2, const Arg3 |
|
371 >::type |
|
372 (a1, a2, a3) |
|
373 ); |
|
374 } |
|
375 |
|
376 template <class Result, class Arg1, class Arg2, class Arg3> |
|
377 inline const |
|
378 lambda_functor< |
|
379 lambda_functor_base< |
|
380 action<3, function_action<3, Result> >, |
|
381 typename detail::bind_tuple_mapper< |
|
382 const Arg1, const Arg2, const Arg3 |
|
383 >::type |
|
384 > |
|
385 > |
|
386 |
|
387 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3) { |
|
388 return |
|
389 lambda_functor_base< |
|
390 action<3, function_action<3, Result> >, |
|
391 typename detail::bind_tuple_mapper< |
|
392 const Arg1, const Arg2, const Arg3 |
|
393 >::type |
|
394 > |
|
395 ( typename detail::bind_tuple_mapper< |
|
396 const Arg1, const Arg2, const Arg3 |
|
397 >::type |
|
398 (a1, a2, a3) |
|
399 ); |
|
400 } |
|
401 |
|
402 |
|
403 #else |
|
404 template <class Arg1, class Arg2, class Arg3> |
|
405 inline const |
|
406 lambda_functor< |
|
407 lambda_functor_base< |
|
408 action<3, function_action<3> >, |
|
409 typename detail::bind_tuple_mapper< |
|
410 typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3 |
|
411 >::type |
|
412 > |
|
413 > |
|
414 |
|
415 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3) { |
|
416 return |
|
417 lambda_functor_base< |
|
418 action<3, function_action<3> >, |
|
419 typename detail::bind_tuple_mapper< |
|
420 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
421 const Arg3 |
|
422 >::type |
|
423 > |
|
424 ( typename detail::bind_tuple_mapper< |
|
425 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
426 const Arg3 |
|
427 >::type |
|
428 (a1, a2, a3) |
|
429 ); |
|
430 } |
|
431 |
|
432 template <class Result, class Arg1, class Arg2, class Arg3> |
|
433 inline const |
|
434 lambda_functor< |
|
435 lambda_functor_base< |
|
436 action<3, function_action<3, Result> >, |
|
437 typename detail::bind_tuple_mapper< |
|
438 typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3 |
|
439 >::type |
|
440 > |
|
441 > |
|
442 |
|
443 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3) { |
|
444 return |
|
445 lambda_functor_base< |
|
446 action<3, function_action<3, Result> >, |
|
447 typename detail::bind_tuple_mapper< |
|
448 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
449 const Arg3 |
|
450 >::type |
|
451 > |
|
452 ( typename detail::bind_tuple_mapper< |
|
453 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
454 const Arg3 |
|
455 >::type |
|
456 (a1, a2, a3) |
|
457 ); |
|
458 } |
|
459 |
|
460 template <class Result, class Par1, class Par2, class Arg2, class Arg3> |
|
461 inline const |
|
462 lambda_functor< |
|
463 lambda_functor_base< |
|
464 action<3, function_action<3, Result> >, |
|
465 typename detail::bind_tuple_mapper< |
|
466 Result(*)(Par1, Par2), const Arg2, const Arg3 |
|
467 >::type |
|
468 > |
|
469 > |
|
470 |
|
471 bind(Result(* const & a1)(Par1, Par2), const Arg2& a2, const Arg3& a3) { |
|
472 return |
|
473 lambda_functor_base< |
|
474 action<3, function_action<3, Result> >, |
|
475 typename detail::bind_tuple_mapper< |
|
476 Result(*)(Par1, Par2), const Arg2, const Arg3 |
|
477 >::type |
|
478 > |
|
479 ( typename detail::bind_tuple_mapper< |
|
480 Result(*)(Par1, Par2), const Arg2, const Arg3 |
|
481 >::type |
|
482 (a1, a2, a3) |
|
483 ); |
|
484 } |
|
485 |
|
486 |
|
487 #endif |
|
488 |
|
489 // 4-argument bind functions -------------------------- |
|
490 #ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T |
|
491 template <class Result, class Par1, class Par2, class Par3, class Arg2, |
|
492 class Arg3, class Arg4> |
|
493 inline const |
|
494 lambda_functor< |
|
495 lambda_functor_base< |
|
496 action<4, function_action<4, Result> >, |
|
497 typename detail::bind_tuple_mapper< |
|
498 Result(&)(Par1, Par2, Par3), const Arg2, const Arg3, const Arg4 |
|
499 >::type |
|
500 > |
|
501 > |
|
502 |
|
503 bind(Result(&a1)(Par1, Par2, Par3), const Arg2& a2, const Arg3& a3, |
|
504 const Arg4& a4) { |
|
505 return |
|
506 lambda_functor_base< |
|
507 action<4, function_action<4, Result> >, |
|
508 typename detail::bind_tuple_mapper< |
|
509 Result(&)(Par1, Par2, Par3), const Arg2, const Arg3, const Arg4 |
|
510 >::type |
|
511 > |
|
512 ( typename detail::bind_tuple_mapper< |
|
513 Result(&)(Par1, Par2, Par3), const Arg2, const Arg3, const Arg4 |
|
514 >::type |
|
515 (a1, a2, a3, a4) |
|
516 ); |
|
517 } |
|
518 #endif |
|
519 |
|
520 #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING |
|
521 template <class Arg1, class Arg2, class Arg3, class Arg4> |
|
522 inline const |
|
523 lambda_functor< |
|
524 lambda_functor_base< |
|
525 action<4, function_action<4> >, |
|
526 typename detail::bind_tuple_mapper< |
|
527 const Arg1, const Arg2, const Arg3, const Arg4 |
|
528 >::type |
|
529 > |
|
530 > |
|
531 |
|
532 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4) { |
|
533 return |
|
534 lambda_functor_base< |
|
535 action<4, function_action<4> >, |
|
536 typename detail::bind_tuple_mapper< |
|
537 const Arg1, const Arg2, const Arg3, const Arg4 |
|
538 >::type |
|
539 > |
|
540 ( typename detail::bind_tuple_mapper< |
|
541 const Arg1, const Arg2, const Arg3, const Arg4 |
|
542 >::type |
|
543 (a1, a2, a3, a4) |
|
544 ); |
|
545 } |
|
546 |
|
547 template <class Result, class Arg1, class Arg2, class Arg3, class Arg4> |
|
548 inline const |
|
549 lambda_functor< |
|
550 lambda_functor_base< |
|
551 action<4, function_action<4, Result> >, |
|
552 typename detail::bind_tuple_mapper< |
|
553 const Arg1, const Arg2, const Arg3, const Arg4 |
|
554 >::type |
|
555 > |
|
556 > |
|
557 |
|
558 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4) { |
|
559 return |
|
560 lambda_functor_base< |
|
561 action<4, function_action<4, Result> >, |
|
562 typename detail::bind_tuple_mapper< |
|
563 const Arg1, const Arg2, const Arg3, const Arg4 |
|
564 >::type |
|
565 > |
|
566 ( typename detail::bind_tuple_mapper< |
|
567 const Arg1, const Arg2, const Arg3, const Arg4 |
|
568 >::type |
|
569 (a1, a2, a3, a4) |
|
570 ); |
|
571 } |
|
572 |
|
573 |
|
574 #else |
|
575 template <class Arg1, class Arg2, class Arg3, class Arg4> |
|
576 inline const |
|
577 lambda_functor< |
|
578 lambda_functor_base< |
|
579 action<4, function_action<4> >, |
|
580 typename detail::bind_tuple_mapper< |
|
581 typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, |
|
582 const Arg4 |
|
583 >::type |
|
584 > |
|
585 > |
|
586 |
|
587 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4) { |
|
588 return |
|
589 lambda_functor_base< |
|
590 action<4, function_action<4> >, |
|
591 typename detail::bind_tuple_mapper< |
|
592 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
593 const Arg3, const Arg4 |
|
594 >::type |
|
595 > |
|
596 ( typename detail::bind_tuple_mapper< |
|
597 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
598 const Arg3, const Arg4 |
|
599 >::type |
|
600 (a1, a2, a3, a4) |
|
601 ); |
|
602 } |
|
603 |
|
604 template <class Result, class Arg1, class Arg2, class Arg3, class Arg4> |
|
605 inline const |
|
606 lambda_functor< |
|
607 lambda_functor_base< |
|
608 action<4, function_action<4, Result> >, |
|
609 typename detail::bind_tuple_mapper< |
|
610 typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, |
|
611 const Arg4 |
|
612 >::type |
|
613 > |
|
614 > |
|
615 |
|
616 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4) { |
|
617 return |
|
618 lambda_functor_base< |
|
619 action<4, function_action<4, Result> >, |
|
620 typename detail::bind_tuple_mapper< |
|
621 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
622 const Arg3, const Arg4 |
|
623 >::type |
|
624 > |
|
625 ( typename detail::bind_tuple_mapper< |
|
626 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
627 const Arg3, const Arg4 |
|
628 >::type |
|
629 (a1, a2, a3, a4) |
|
630 ); |
|
631 } |
|
632 |
|
633 template <class Result, class Par1, class Par2, class Par3, class Arg2, |
|
634 class Arg3, class Arg4> |
|
635 inline const |
|
636 lambda_functor< |
|
637 lambda_functor_base< |
|
638 action<4, function_action<4, Result> >, |
|
639 typename detail::bind_tuple_mapper< |
|
640 Result(*)(Par1, Par2, Par3), const Arg2, const Arg3, const Arg4 |
|
641 >::type |
|
642 > |
|
643 > |
|
644 |
|
645 bind(Result(* const & a1)(Par1, Par2, Par3), const Arg2& a2, |
|
646 const Arg3& a3, const Arg4& a4) { |
|
647 return |
|
648 lambda_functor_base< |
|
649 action<4, function_action<4, Result> >, |
|
650 typename detail::bind_tuple_mapper< |
|
651 Result(*)(Par1, Par2, Par3), const Arg2, const Arg3, const Arg4 |
|
652 >::type |
|
653 > |
|
654 ( typename detail::bind_tuple_mapper< |
|
655 Result(*)(Par1, Par2, Par3), const Arg2, const Arg3, const Arg4 |
|
656 >::type |
|
657 (a1, a2, a3, a4) |
|
658 ); |
|
659 } |
|
660 |
|
661 |
|
662 #endif |
|
663 |
|
664 // 5-argument bind functions -------------------------- |
|
665 #ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T |
|
666 template <class Result, class Par1, class Par2, class Par3, class Par4, |
|
667 class Arg2, class Arg3, class Arg4, class Arg5> |
|
668 inline const |
|
669 lambda_functor< |
|
670 lambda_functor_base< |
|
671 action<5, function_action<5, Result> >, |
|
672 typename detail::bind_tuple_mapper< |
|
673 Result(&)(Par1, Par2, Par3, Par4), const Arg2, const Arg3, const Arg4, |
|
674 const Arg5 |
|
675 >::type |
|
676 > |
|
677 > |
|
678 |
|
679 bind(Result(&a1)(Par1, Par2, Par3, Par4), const Arg2& a2, const Arg3& a3, |
|
680 const Arg4& a4, const Arg5& a5) { |
|
681 return |
|
682 lambda_functor_base< |
|
683 action<5, function_action<5, Result> >, |
|
684 typename detail::bind_tuple_mapper< |
|
685 Result(&)(Par1, Par2, Par3, Par4), const Arg2, const Arg3, const Arg4, |
|
686 const Arg5 |
|
687 >::type |
|
688 > |
|
689 ( typename detail::bind_tuple_mapper< |
|
690 Result(&)(Par1, Par2, Par3, Par4), const Arg2, const Arg3, const Arg4, |
|
691 const Arg5 |
|
692 >::type |
|
693 (a1, a2, a3, a4, a5) |
|
694 ); |
|
695 } |
|
696 #endif |
|
697 |
|
698 #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING |
|
699 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> |
|
700 inline const |
|
701 lambda_functor< |
|
702 lambda_functor_base< |
|
703 action<5, function_action<5> >, |
|
704 typename detail::bind_tuple_mapper< |
|
705 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5 |
|
706 >::type |
|
707 > |
|
708 > |
|
709 |
|
710 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
711 const Arg5& a5) { |
|
712 return |
|
713 lambda_functor_base< |
|
714 action<5, function_action<5> >, |
|
715 typename detail::bind_tuple_mapper< |
|
716 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5 |
|
717 >::type |
|
718 > |
|
719 ( typename detail::bind_tuple_mapper< |
|
720 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5 |
|
721 >::type |
|
722 (a1, a2, a3, a4, a5) |
|
723 ); |
|
724 } |
|
725 |
|
726 template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, |
|
727 class Arg5> |
|
728 inline const |
|
729 lambda_functor< |
|
730 lambda_functor_base< |
|
731 action<5, function_action<5, Result> >, |
|
732 typename detail::bind_tuple_mapper< |
|
733 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5 |
|
734 >::type |
|
735 > |
|
736 > |
|
737 |
|
738 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
739 const Arg5& a5) { |
|
740 return |
|
741 lambda_functor_base< |
|
742 action<5, function_action<5, Result> >, |
|
743 typename detail::bind_tuple_mapper< |
|
744 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5 |
|
745 >::type |
|
746 > |
|
747 ( typename detail::bind_tuple_mapper< |
|
748 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5 |
|
749 >::type |
|
750 (a1, a2, a3, a4, a5) |
|
751 ); |
|
752 } |
|
753 |
|
754 |
|
755 #else |
|
756 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> |
|
757 inline const |
|
758 lambda_functor< |
|
759 lambda_functor_base< |
|
760 action<5, function_action<5> >, |
|
761 typename detail::bind_tuple_mapper< |
|
762 typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, |
|
763 const Arg4, const Arg5 |
|
764 >::type |
|
765 > |
|
766 > |
|
767 |
|
768 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
769 const Arg5& a5) { |
|
770 return |
|
771 lambda_functor_base< |
|
772 action<5, function_action<5> >, |
|
773 typename detail::bind_tuple_mapper< |
|
774 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
775 const Arg3, const Arg4, const Arg5 |
|
776 >::type |
|
777 > |
|
778 ( typename detail::bind_tuple_mapper< |
|
779 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
780 const Arg3, const Arg4, const Arg5 |
|
781 >::type |
|
782 (a1, a2, a3, a4, a5) |
|
783 ); |
|
784 } |
|
785 |
|
786 template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, |
|
787 class Arg5> |
|
788 inline const |
|
789 lambda_functor< |
|
790 lambda_functor_base< |
|
791 action<5, function_action<5, Result> >, |
|
792 typename detail::bind_tuple_mapper< |
|
793 typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, |
|
794 const Arg4, const Arg5 |
|
795 >::type |
|
796 > |
|
797 > |
|
798 |
|
799 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
800 const Arg5& a5) { |
|
801 return |
|
802 lambda_functor_base< |
|
803 action<5, function_action<5, Result> >, |
|
804 typename detail::bind_tuple_mapper< |
|
805 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
806 const Arg3, const Arg4, const Arg5 |
|
807 >::type |
|
808 > |
|
809 ( typename detail::bind_tuple_mapper< |
|
810 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
811 const Arg3, const Arg4, const Arg5 |
|
812 >::type |
|
813 (a1, a2, a3, a4, a5) |
|
814 ); |
|
815 } |
|
816 |
|
817 template <class Result, class Par1, class Par2, class Par3, class Par4, |
|
818 class Arg2, class Arg3, class Arg4, class Arg5> |
|
819 inline const |
|
820 lambda_functor< |
|
821 lambda_functor_base< |
|
822 action<5, function_action<5, Result> >, |
|
823 typename detail::bind_tuple_mapper< |
|
824 Result(*)(Par1, Par2, Par3, Par4), const Arg2, const Arg3, const Arg4, |
|
825 const Arg5 |
|
826 >::type |
|
827 > |
|
828 > |
|
829 |
|
830 bind(Result(* const & a1)(Par1, Par2, Par3, Par4), const Arg2& a2, |
|
831 const Arg3& a3, const Arg4& a4, const Arg5& a5) { |
|
832 return |
|
833 lambda_functor_base< |
|
834 action<5, function_action<5, Result> >, |
|
835 typename detail::bind_tuple_mapper< |
|
836 Result(*)(Par1, Par2, Par3, Par4), const Arg2, const Arg3, const Arg4, |
|
837 const Arg5 |
|
838 >::type |
|
839 > |
|
840 ( typename detail::bind_tuple_mapper< |
|
841 Result(*)(Par1, Par2, Par3, Par4), const Arg2, const Arg3, const Arg4, |
|
842 const Arg5 |
|
843 >::type |
|
844 (a1, a2, a3, a4, a5) |
|
845 ); |
|
846 } |
|
847 |
|
848 |
|
849 #endif |
|
850 |
|
851 // 6-argument bind functions -------------------------- |
|
852 #ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T |
|
853 template <class Result, class Par1, class Par2, class Par3, class Par4, |
|
854 class Par5, class Arg2, class Arg3, class Arg4, class Arg5, |
|
855 class Arg6> |
|
856 inline const |
|
857 lambda_functor< |
|
858 lambda_functor_base< |
|
859 action<6, function_action<6, Result> >, |
|
860 typename detail::bind_tuple_mapper< |
|
861 Result(&)(Par1, Par2, Par3, Par4, Par5), const Arg2, const Arg3, |
|
862 const Arg4, const Arg5, const Arg6 |
|
863 >::type |
|
864 > |
|
865 > |
|
866 |
|
867 bind(Result(&a1)(Par1, Par2, Par3, Par4, Par5), const Arg2& a2, |
|
868 const Arg3& a3, const Arg4& a4, const Arg5& a5, const Arg6& a6) { |
|
869 return |
|
870 lambda_functor_base< |
|
871 action<6, function_action<6, Result> >, |
|
872 typename detail::bind_tuple_mapper< |
|
873 Result(&)(Par1, Par2, Par3, Par4, Par5), const Arg2, const Arg3, |
|
874 const Arg4, const Arg5, const Arg6 |
|
875 >::type |
|
876 > |
|
877 ( typename detail::bind_tuple_mapper< |
|
878 Result(&)(Par1, Par2, Par3, Par4, Par5), const Arg2, const Arg3, |
|
879 const Arg4, const Arg5, const Arg6 |
|
880 >::type |
|
881 (a1, a2, a3, a4, a5, a6) |
|
882 ); |
|
883 } |
|
884 #endif |
|
885 |
|
886 #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING |
|
887 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, |
|
888 class Arg6> |
|
889 inline const |
|
890 lambda_functor< |
|
891 lambda_functor_base< |
|
892 action<6, function_action<6> >, |
|
893 typename detail::bind_tuple_mapper< |
|
894 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6 |
|
895 >::type |
|
896 > |
|
897 > |
|
898 |
|
899 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
900 const Arg5& a5, const Arg6& a6) { |
|
901 return |
|
902 lambda_functor_base< |
|
903 action<6, function_action<6> >, |
|
904 typename detail::bind_tuple_mapper< |
|
905 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6 |
|
906 >::type |
|
907 > |
|
908 ( typename detail::bind_tuple_mapper< |
|
909 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6 |
|
910 >::type |
|
911 (a1, a2, a3, a4, a5, a6) |
|
912 ); |
|
913 } |
|
914 |
|
915 template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, |
|
916 class Arg5, class Arg6> |
|
917 inline const |
|
918 lambda_functor< |
|
919 lambda_functor_base< |
|
920 action<6, function_action<6, Result> >, |
|
921 typename detail::bind_tuple_mapper< |
|
922 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6 |
|
923 >::type |
|
924 > |
|
925 > |
|
926 |
|
927 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
928 const Arg5& a5, const Arg6& a6) { |
|
929 return |
|
930 lambda_functor_base< |
|
931 action<6, function_action<6, Result> >, |
|
932 typename detail::bind_tuple_mapper< |
|
933 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6 |
|
934 >::type |
|
935 > |
|
936 ( typename detail::bind_tuple_mapper< |
|
937 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6 |
|
938 >::type |
|
939 (a1, a2, a3, a4, a5, a6) |
|
940 ); |
|
941 } |
|
942 |
|
943 |
|
944 #else |
|
945 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, |
|
946 class Arg6> |
|
947 inline const |
|
948 lambda_functor< |
|
949 lambda_functor_base< |
|
950 action<6, function_action<6> >, |
|
951 typename detail::bind_tuple_mapper< |
|
952 typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, |
|
953 const Arg4, const Arg5, const Arg6 |
|
954 >::type |
|
955 > |
|
956 > |
|
957 |
|
958 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
959 const Arg5& a5, const Arg6& a6) { |
|
960 return |
|
961 lambda_functor_base< |
|
962 action<6, function_action<6> >, |
|
963 typename detail::bind_tuple_mapper< |
|
964 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
965 const Arg3, const Arg4, const Arg5, const Arg6 |
|
966 >::type |
|
967 > |
|
968 ( typename detail::bind_tuple_mapper< |
|
969 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
970 const Arg3, const Arg4, const Arg5, const Arg6 |
|
971 >::type |
|
972 (a1, a2, a3, a4, a5, a6) |
|
973 ); |
|
974 } |
|
975 |
|
976 template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, |
|
977 class Arg5, class Arg6> |
|
978 inline const |
|
979 lambda_functor< |
|
980 lambda_functor_base< |
|
981 action<6, function_action<6, Result> >, |
|
982 typename detail::bind_tuple_mapper< |
|
983 typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, |
|
984 const Arg4, const Arg5, const Arg6 |
|
985 >::type |
|
986 > |
|
987 > |
|
988 |
|
989 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
990 const Arg5& a5, const Arg6& a6) { |
|
991 return |
|
992 lambda_functor_base< |
|
993 action<6, function_action<6, Result> >, |
|
994 typename detail::bind_tuple_mapper< |
|
995 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
996 const Arg3, const Arg4, const Arg5, const Arg6 |
|
997 >::type |
|
998 > |
|
999 ( typename detail::bind_tuple_mapper< |
|
1000 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
1001 const Arg3, const Arg4, const Arg5, const Arg6 |
|
1002 >::type |
|
1003 (a1, a2, a3, a4, a5, a6) |
|
1004 ); |
|
1005 } |
|
1006 |
|
1007 template <class Result, class Par1, class Par2, class Par3, class Par4, |
|
1008 class Par5, class Arg2, class Arg3, class Arg4, class Arg5, |
|
1009 class Arg6> |
|
1010 inline const |
|
1011 lambda_functor< |
|
1012 lambda_functor_base< |
|
1013 action<6, function_action<6, Result> >, |
|
1014 typename detail::bind_tuple_mapper< |
|
1015 Result(*)(Par1, Par2, Par3, Par4, Par5), const Arg2, const Arg3, |
|
1016 const Arg4, const Arg5, const Arg6 |
|
1017 >::type |
|
1018 > |
|
1019 > |
|
1020 |
|
1021 bind(Result(* const & a1)(Par1, Par2, Par3, Par4, Par5), const Arg2& a2, |
|
1022 const Arg3& a3, const Arg4& a4, const Arg5& a5, const Arg6& a6) { |
|
1023 return |
|
1024 lambda_functor_base< |
|
1025 action<6, function_action<6, Result> >, |
|
1026 typename detail::bind_tuple_mapper< |
|
1027 Result(*)(Par1, Par2, Par3, Par4, Par5), const Arg2, const Arg3, |
|
1028 const Arg4, const Arg5, const Arg6 |
|
1029 >::type |
|
1030 > |
|
1031 ( typename detail::bind_tuple_mapper< |
|
1032 Result(*)(Par1, Par2, Par3, Par4, Par5), const Arg2, const Arg3, |
|
1033 const Arg4, const Arg5, const Arg6 |
|
1034 >::type |
|
1035 (a1, a2, a3, a4, a5, a6) |
|
1036 ); |
|
1037 } |
|
1038 |
|
1039 |
|
1040 #endif |
|
1041 |
|
1042 // 7-argument bind functions -------------------------- |
|
1043 #ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T |
|
1044 template <class Result, class Par1, class Par2, class Par3, class Par4, |
|
1045 class Par5, class Par6, class Arg2, class Arg3, class Arg4, |
|
1046 class Arg5, class Arg6, class Arg7> |
|
1047 inline const |
|
1048 lambda_functor< |
|
1049 lambda_functor_base< |
|
1050 action<7, function_action<7, Result> >, |
|
1051 typename detail::bind_tuple_mapper< |
|
1052 Result(&)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2, const Arg3, |
|
1053 const Arg4, const Arg5, const Arg6, const Arg7 |
|
1054 >::type |
|
1055 > |
|
1056 > |
|
1057 |
|
1058 bind(Result(&a1)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2& a2, |
|
1059 const Arg3& a3, const Arg4& a4, const Arg5& a5, const Arg6& a6, |
|
1060 const Arg7& a7) { |
|
1061 return |
|
1062 lambda_functor_base< |
|
1063 action<7, function_action<7, Result> >, |
|
1064 typename detail::bind_tuple_mapper< |
|
1065 Result(&)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2, const Arg3, |
|
1066 const Arg4, const Arg5, const Arg6, const Arg7 |
|
1067 >::type |
|
1068 > |
|
1069 ( typename detail::bind_tuple_mapper< |
|
1070 Result(&)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2, const Arg3, |
|
1071 const Arg4, const Arg5, const Arg6, const Arg7 |
|
1072 >::type |
|
1073 (a1, a2, a3, a4, a5, a6, a7) |
|
1074 ); |
|
1075 } |
|
1076 #endif |
|
1077 |
|
1078 #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING |
|
1079 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, |
|
1080 class Arg6, class Arg7> |
|
1081 inline const |
|
1082 lambda_functor< |
|
1083 lambda_functor_base< |
|
1084 action<7, function_action<7> >, |
|
1085 typename detail::bind_tuple_mapper< |
|
1086 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, |
|
1087 const Arg7 |
|
1088 >::type |
|
1089 > |
|
1090 > |
|
1091 |
|
1092 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
1093 const Arg5& a5, const Arg6& a6, const Arg7& a7) { |
|
1094 return |
|
1095 lambda_functor_base< |
|
1096 action<7, function_action<7> >, |
|
1097 typename detail::bind_tuple_mapper< |
|
1098 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, |
|
1099 const Arg6, const Arg7 |
|
1100 >::type |
|
1101 > |
|
1102 ( typename detail::bind_tuple_mapper< |
|
1103 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, |
|
1104 const Arg6, const Arg7 |
|
1105 >::type |
|
1106 (a1, a2, a3, a4, a5, a6, a7) |
|
1107 ); |
|
1108 } |
|
1109 |
|
1110 template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, |
|
1111 class Arg5, class Arg6, class Arg7> |
|
1112 inline const |
|
1113 lambda_functor< |
|
1114 lambda_functor_base< |
|
1115 action<7, function_action<7, Result> >, |
|
1116 typename detail::bind_tuple_mapper< |
|
1117 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, |
|
1118 const Arg7 |
|
1119 >::type |
|
1120 > |
|
1121 > |
|
1122 |
|
1123 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
1124 const Arg5& a5, const Arg6& a6, const Arg7& a7) { |
|
1125 return |
|
1126 lambda_functor_base< |
|
1127 action<7, function_action<7, Result> >, |
|
1128 typename detail::bind_tuple_mapper< |
|
1129 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, |
|
1130 const Arg6, const Arg7 |
|
1131 >::type |
|
1132 > |
|
1133 ( typename detail::bind_tuple_mapper< |
|
1134 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, |
|
1135 const Arg6, const Arg7 |
|
1136 >::type |
|
1137 (a1, a2, a3, a4, a5, a6, a7) |
|
1138 ); |
|
1139 } |
|
1140 |
|
1141 |
|
1142 #else |
|
1143 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, |
|
1144 class Arg6, class Arg7> |
|
1145 inline const |
|
1146 lambda_functor< |
|
1147 lambda_functor_base< |
|
1148 action<7, function_action<7> >, |
|
1149 typename detail::bind_tuple_mapper< |
|
1150 typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, |
|
1151 const Arg4, const Arg5, const Arg6, const Arg7 |
|
1152 >::type |
|
1153 > |
|
1154 > |
|
1155 |
|
1156 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
1157 const Arg5& a5, const Arg6& a6, const Arg7& a7) { |
|
1158 return |
|
1159 lambda_functor_base< |
|
1160 action<7, function_action<7> >, |
|
1161 typename detail::bind_tuple_mapper< |
|
1162 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
1163 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7 |
|
1164 >::type |
|
1165 > |
|
1166 ( typename detail::bind_tuple_mapper< |
|
1167 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
1168 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7 |
|
1169 >::type |
|
1170 (a1, a2, a3, a4, a5, a6, a7) |
|
1171 ); |
|
1172 } |
|
1173 |
|
1174 template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, |
|
1175 class Arg5, class Arg6, class Arg7> |
|
1176 inline const |
|
1177 lambda_functor< |
|
1178 lambda_functor_base< |
|
1179 action<7, function_action<7, Result> >, |
|
1180 typename detail::bind_tuple_mapper< |
|
1181 typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, |
|
1182 const Arg4, const Arg5, const Arg6, const Arg7 |
|
1183 >::type |
|
1184 > |
|
1185 > |
|
1186 |
|
1187 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
1188 const Arg5& a5, const Arg6& a6, const Arg7& a7) { |
|
1189 return |
|
1190 lambda_functor_base< |
|
1191 action<7, function_action<7, Result> >, |
|
1192 typename detail::bind_tuple_mapper< |
|
1193 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
1194 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7 |
|
1195 >::type |
|
1196 > |
|
1197 ( typename detail::bind_tuple_mapper< |
|
1198 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
1199 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7 |
|
1200 >::type |
|
1201 (a1, a2, a3, a4, a5, a6, a7) |
|
1202 ); |
|
1203 } |
|
1204 |
|
1205 template <class Result, class Par1, class Par2, class Par3, class Par4, |
|
1206 class Par5, class Par6, class Arg2, class Arg3, class Arg4, |
|
1207 class Arg5, class Arg6, class Arg7> |
|
1208 inline const |
|
1209 lambda_functor< |
|
1210 lambda_functor_base< |
|
1211 action<7, function_action<7, Result> >, |
|
1212 typename detail::bind_tuple_mapper< |
|
1213 Result(*)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2, const Arg3, |
|
1214 const Arg4, const Arg5, const Arg6, const Arg7 |
|
1215 >::type |
|
1216 > |
|
1217 > |
|
1218 |
|
1219 bind(Result(* const & a1)(Par1, Par2, Par3, Par4, Par5, Par6), |
|
1220 const Arg2& a2, const Arg3& a3, const Arg4& a4, const Arg5& a5, |
|
1221 const Arg6& a6, const Arg7& a7) { |
|
1222 return |
|
1223 lambda_functor_base< |
|
1224 action<7, function_action<7, Result> >, |
|
1225 typename detail::bind_tuple_mapper< |
|
1226 Result(*)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2, const Arg3, |
|
1227 const Arg4, const Arg5, const Arg6, const Arg7 |
|
1228 >::type |
|
1229 > |
|
1230 ( typename detail::bind_tuple_mapper< |
|
1231 Result(*)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2, const Arg3, |
|
1232 const Arg4, const Arg5, const Arg6, const Arg7 |
|
1233 >::type |
|
1234 (a1, a2, a3, a4, a5, a6, a7) |
|
1235 ); |
|
1236 } |
|
1237 |
|
1238 |
|
1239 #endif |
|
1240 |
|
1241 // 8-argument bind functions -------------------------- |
|
1242 #ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T |
|
1243 template <class Result, class Par1, class Par2, class Par3, class Par4, |
|
1244 class Par5, class Par6, class Par7, class Arg2, class Arg3, |
|
1245 class Arg4, class Arg5, class Arg6, class Arg7, class Arg8> |
|
1246 inline const |
|
1247 lambda_functor< |
|
1248 lambda_functor_base< |
|
1249 action<8, function_action<8, Result> >, |
|
1250 typename detail::bind_tuple_mapper< |
|
1251 Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2, |
|
1252 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 |
|
1253 >::type |
|
1254 > |
|
1255 > |
|
1256 |
|
1257 bind(Result(&a1)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2& a2, |
|
1258 const Arg3& a3, const Arg4& a4, const Arg5& a5, const Arg6& a6, |
|
1259 const Arg7& a7, const Arg8& a8) { |
|
1260 return |
|
1261 lambda_functor_base< |
|
1262 action<8, function_action<8, Result> >, |
|
1263 typename detail::bind_tuple_mapper< |
|
1264 Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2, |
|
1265 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 |
|
1266 >::type |
|
1267 > |
|
1268 ( typename detail::bind_tuple_mapper< |
|
1269 Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2, |
|
1270 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 |
|
1271 >::type |
|
1272 (a1, a2, a3, a4, a5, a6, a7, a8) |
|
1273 ); |
|
1274 } |
|
1275 #endif |
|
1276 |
|
1277 #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING |
|
1278 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, |
|
1279 class Arg6, class Arg7, class Arg8> |
|
1280 inline const |
|
1281 lambda_functor< |
|
1282 lambda_functor_base< |
|
1283 action<8, function_action<8> >, |
|
1284 typename detail::bind_tuple_mapper< |
|
1285 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, |
|
1286 const Arg7, const Arg8 |
|
1287 >::type |
|
1288 > |
|
1289 > |
|
1290 |
|
1291 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
1292 const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8) { |
|
1293 return |
|
1294 lambda_functor_base< |
|
1295 action<8, function_action<8> >, |
|
1296 typename detail::bind_tuple_mapper< |
|
1297 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, |
|
1298 const Arg6, const Arg7, const Arg8 |
|
1299 >::type |
|
1300 > |
|
1301 ( typename detail::bind_tuple_mapper< |
|
1302 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, |
|
1303 const Arg6, const Arg7, const Arg8 |
|
1304 >::type |
|
1305 (a1, a2, a3, a4, a5, a6, a7, a8) |
|
1306 ); |
|
1307 } |
|
1308 |
|
1309 template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, |
|
1310 class Arg5, class Arg6, class Arg7, class Arg8> |
|
1311 inline const |
|
1312 lambda_functor< |
|
1313 lambda_functor_base< |
|
1314 action<8, function_action<8, Result> >, |
|
1315 typename detail::bind_tuple_mapper< |
|
1316 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, |
|
1317 const Arg7, const Arg8 |
|
1318 >::type |
|
1319 > |
|
1320 > |
|
1321 |
|
1322 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
1323 const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8) { |
|
1324 return |
|
1325 lambda_functor_base< |
|
1326 action<8, function_action<8, Result> >, |
|
1327 typename detail::bind_tuple_mapper< |
|
1328 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, |
|
1329 const Arg6, const Arg7, const Arg8 |
|
1330 >::type |
|
1331 > |
|
1332 ( typename detail::bind_tuple_mapper< |
|
1333 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, |
|
1334 const Arg6, const Arg7, const Arg8 |
|
1335 >::type |
|
1336 (a1, a2, a3, a4, a5, a6, a7, a8) |
|
1337 ); |
|
1338 } |
|
1339 |
|
1340 |
|
1341 #else |
|
1342 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, |
|
1343 class Arg6, class Arg7, class Arg8> |
|
1344 inline const |
|
1345 lambda_functor< |
|
1346 lambda_functor_base< |
|
1347 action<8, function_action<8> >, |
|
1348 typename detail::bind_tuple_mapper< |
|
1349 typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, |
|
1350 const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 |
|
1351 >::type |
|
1352 > |
|
1353 > |
|
1354 |
|
1355 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
1356 const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8) { |
|
1357 return |
|
1358 lambda_functor_base< |
|
1359 action<8, function_action<8> >, |
|
1360 typename detail::bind_tuple_mapper< |
|
1361 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
1362 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 |
|
1363 >::type |
|
1364 > |
|
1365 ( typename detail::bind_tuple_mapper< |
|
1366 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
1367 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 |
|
1368 >::type |
|
1369 (a1, a2, a3, a4, a5, a6, a7, a8) |
|
1370 ); |
|
1371 } |
|
1372 |
|
1373 template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, |
|
1374 class Arg5, class Arg6, class Arg7, class Arg8> |
|
1375 inline const |
|
1376 lambda_functor< |
|
1377 lambda_functor_base< |
|
1378 action<8, function_action<8, Result> >, |
|
1379 typename detail::bind_tuple_mapper< |
|
1380 typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, |
|
1381 const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 |
|
1382 >::type |
|
1383 > |
|
1384 > |
|
1385 |
|
1386 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
1387 const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8) { |
|
1388 return |
|
1389 lambda_functor_base< |
|
1390 action<8, function_action<8, Result> >, |
|
1391 typename detail::bind_tuple_mapper< |
|
1392 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
1393 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 |
|
1394 >::type |
|
1395 > |
|
1396 ( typename detail::bind_tuple_mapper< |
|
1397 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
1398 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 |
|
1399 >::type |
|
1400 (a1, a2, a3, a4, a5, a6, a7, a8) |
|
1401 ); |
|
1402 } |
|
1403 |
|
1404 template <class Result, class Par1, class Par2, class Par3, class Par4, |
|
1405 class Par5, class Par6, class Par7, class Arg2, class Arg3, |
|
1406 class Arg4, class Arg5, class Arg6, class Arg7, class Arg8> |
|
1407 inline const |
|
1408 lambda_functor< |
|
1409 lambda_functor_base< |
|
1410 action<8, function_action<8, Result> >, |
|
1411 typename detail::bind_tuple_mapper< |
|
1412 Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2, |
|
1413 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 |
|
1414 >::type |
|
1415 > |
|
1416 > |
|
1417 |
|
1418 bind(Result(* const & a1)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), |
|
1419 const Arg2& a2, const Arg3& a3, const Arg4& a4, const Arg5& a5, |
|
1420 const Arg6& a6, const Arg7& a7, const Arg8& a8) { |
|
1421 return |
|
1422 lambda_functor_base< |
|
1423 action<8, function_action<8, Result> >, |
|
1424 typename detail::bind_tuple_mapper< |
|
1425 Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2, |
|
1426 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 |
|
1427 >::type |
|
1428 > |
|
1429 ( typename detail::bind_tuple_mapper< |
|
1430 Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2, |
|
1431 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 |
|
1432 >::type |
|
1433 (a1, a2, a3, a4, a5, a6, a7, a8) |
|
1434 ); |
|
1435 } |
|
1436 |
|
1437 |
|
1438 #endif |
|
1439 |
|
1440 // 9-argument bind functions -------------------------- |
|
1441 #ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T |
|
1442 template <class Result, class Par1, class Par2, class Par3, class Par4, |
|
1443 class Par5, class Par6, class Par7, class Par8, class Arg2, |
|
1444 class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, |
|
1445 class Arg8, class Arg9> |
|
1446 inline const |
|
1447 lambda_functor< |
|
1448 lambda_functor_base< |
|
1449 action<9, function_action<9, Result> >, |
|
1450 typename detail::bind_tuple_mapper< |
|
1451 Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), const Arg2, |
|
1452 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8, |
|
1453 const Arg9 |
|
1454 >::type |
|
1455 > |
|
1456 > |
|
1457 |
|
1458 bind(Result(&a1)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), |
|
1459 const Arg2& a2, const Arg3& a3, const Arg4& a4, const Arg5& a5, |
|
1460 const Arg6& a6, const Arg7& a7, const Arg8& a8, const Arg9& a9) { |
|
1461 return |
|
1462 lambda_functor_base< |
|
1463 action<9, function_action<9, Result> >, |
|
1464 typename detail::bind_tuple_mapper< |
|
1465 Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), const Arg2, |
|
1466 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, |
|
1467 const Arg8, const Arg9 |
|
1468 >::type |
|
1469 > |
|
1470 ( typename detail::bind_tuple_mapper< |
|
1471 Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), const Arg2, |
|
1472 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, |
|
1473 const Arg8, const Arg9 |
|
1474 >::type |
|
1475 (a1, a2, a3, a4, a5, a6, a7, a8, a9) |
|
1476 ); |
|
1477 } |
|
1478 #endif |
|
1479 |
|
1480 #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING |
|
1481 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, |
|
1482 class Arg6, class Arg7, class Arg8, class Arg9> |
|
1483 inline const |
|
1484 lambda_functor< |
|
1485 lambda_functor_base< |
|
1486 action<9, function_action<9> >, |
|
1487 typename detail::bind_tuple_mapper< |
|
1488 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, |
|
1489 const Arg7, const Arg8, const Arg9 |
|
1490 >::type |
|
1491 > |
|
1492 > |
|
1493 |
|
1494 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
1495 const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8, |
|
1496 const Arg9& a9) { |
|
1497 return |
|
1498 lambda_functor_base< |
|
1499 action<9, function_action<9> >, |
|
1500 typename detail::bind_tuple_mapper< |
|
1501 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, |
|
1502 const Arg6, const Arg7, const Arg8, const Arg9 |
|
1503 >::type |
|
1504 > |
|
1505 ( typename detail::bind_tuple_mapper< |
|
1506 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, |
|
1507 const Arg6, const Arg7, const Arg8, const Arg9 |
|
1508 >::type |
|
1509 (a1, a2, a3, a4, a5, a6, a7, a8, a9) |
|
1510 ); |
|
1511 } |
|
1512 |
|
1513 template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, |
|
1514 class Arg5, class Arg6, class Arg7, class Arg8, class Arg9> |
|
1515 inline const |
|
1516 lambda_functor< |
|
1517 lambda_functor_base< |
|
1518 action<9, function_action<9, Result> >, |
|
1519 typename detail::bind_tuple_mapper< |
|
1520 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, |
|
1521 const Arg7, const Arg8, const Arg9 |
|
1522 >::type |
|
1523 > |
|
1524 > |
|
1525 |
|
1526 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
1527 const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8, |
|
1528 const Arg9& a9) { |
|
1529 return |
|
1530 lambda_functor_base< |
|
1531 action<9, function_action<9, Result> >, |
|
1532 typename detail::bind_tuple_mapper< |
|
1533 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, |
|
1534 const Arg6, const Arg7, const Arg8, const Arg9 |
|
1535 >::type |
|
1536 > |
|
1537 ( typename detail::bind_tuple_mapper< |
|
1538 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, |
|
1539 const Arg6, const Arg7, const Arg8, const Arg9 |
|
1540 >::type |
|
1541 (a1, a2, a3, a4, a5, a6, a7, a8, a9) |
|
1542 ); |
|
1543 } |
|
1544 |
|
1545 |
|
1546 #else |
|
1547 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, |
|
1548 class Arg6, class Arg7, class Arg8, class Arg9> |
|
1549 inline const |
|
1550 lambda_functor< |
|
1551 lambda_functor_base< |
|
1552 action<9, function_action<9> >, |
|
1553 typename detail::bind_tuple_mapper< |
|
1554 typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, |
|
1555 const Arg4, const Arg5, const Arg6, const Arg7, const Arg8, const Arg9 |
|
1556 >::type |
|
1557 > |
|
1558 > |
|
1559 |
|
1560 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
1561 const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8, |
|
1562 const Arg9& a9) { |
|
1563 return |
|
1564 lambda_functor_base< |
|
1565 action<9, function_action<9> >, |
|
1566 typename detail::bind_tuple_mapper< |
|
1567 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
1568 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, |
|
1569 const Arg8, const Arg9 |
|
1570 >::type |
|
1571 > |
|
1572 ( typename detail::bind_tuple_mapper< |
|
1573 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
1574 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, |
|
1575 const Arg8, const Arg9 |
|
1576 >::type |
|
1577 (a1, a2, a3, a4, a5, a6, a7, a8, a9) |
|
1578 ); |
|
1579 } |
|
1580 |
|
1581 template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, |
|
1582 class Arg5, class Arg6, class Arg7, class Arg8, class Arg9> |
|
1583 inline const |
|
1584 lambda_functor< |
|
1585 lambda_functor_base< |
|
1586 action<9, function_action<9, Result> >, |
|
1587 typename detail::bind_tuple_mapper< |
|
1588 typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, |
|
1589 const Arg4, const Arg5, const Arg6, const Arg7, const Arg8, const Arg9 |
|
1590 >::type |
|
1591 > |
|
1592 > |
|
1593 |
|
1594 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
1595 const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8, |
|
1596 const Arg9& a9) { |
|
1597 return |
|
1598 lambda_functor_base< |
|
1599 action<9, function_action<9, Result> >, |
|
1600 typename detail::bind_tuple_mapper< |
|
1601 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
1602 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, |
|
1603 const Arg8, const Arg9 |
|
1604 >::type |
|
1605 > |
|
1606 ( typename detail::bind_tuple_mapper< |
|
1607 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
1608 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, |
|
1609 const Arg8, const Arg9 |
|
1610 >::type |
|
1611 (a1, a2, a3, a4, a5, a6, a7, a8, a9) |
|
1612 ); |
|
1613 } |
|
1614 |
|
1615 template <class Result, class Par1, class Par2, class Par3, class Par4, |
|
1616 class Par5, class Par6, class Par7, class Par8, class Arg2, |
|
1617 class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, |
|
1618 class Arg8, class Arg9> |
|
1619 inline const |
|
1620 lambda_functor< |
|
1621 lambda_functor_base< |
|
1622 action<9, function_action<9, Result> >, |
|
1623 typename detail::bind_tuple_mapper< |
|
1624 Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), const Arg2, |
|
1625 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8, |
|
1626 const Arg9 |
|
1627 >::type |
|
1628 > |
|
1629 > |
|
1630 |
|
1631 bind(Result(* const & a1)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), |
|
1632 const Arg2& a2, const Arg3& a3, const Arg4& a4, const Arg5& a5, |
|
1633 const Arg6& a6, const Arg7& a7, const Arg8& a8, const Arg9& a9) { |
|
1634 return |
|
1635 lambda_functor_base< |
|
1636 action<9, function_action<9, Result> >, |
|
1637 typename detail::bind_tuple_mapper< |
|
1638 Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), const Arg2, |
|
1639 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, |
|
1640 const Arg8, const Arg9 |
|
1641 >::type |
|
1642 > |
|
1643 ( typename detail::bind_tuple_mapper< |
|
1644 Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), const Arg2, |
|
1645 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, |
|
1646 const Arg8, const Arg9 |
|
1647 >::type |
|
1648 (a1, a2, a3, a4, a5, a6, a7, a8, a9) |
|
1649 ); |
|
1650 } |
|
1651 |
|
1652 |
|
1653 #endif |
|
1654 |
|
1655 // 10-argument bind functions -------------------------- |
|
1656 #ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T |
|
1657 template <class Result, class Par1, class Par2, class Par3, class Par4, |
|
1658 class Par5, class Par6, class Par7, class Par8, class Par9, |
|
1659 class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, |
|
1660 class Arg7, class Arg8, class Arg9, class Arg10> |
|
1661 inline const |
|
1662 lambda_functor< |
|
1663 lambda_functor_base< |
|
1664 action<10, function_action<10, Result> >, |
|
1665 typename detail::bind_tuple_mapper< |
|
1666 Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9), |
|
1667 const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, |
|
1668 const Arg8, const Arg9, const Arg10 |
|
1669 >::type |
|
1670 > |
|
1671 > |
|
1672 |
|
1673 bind(Result(&a1)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9), |
|
1674 const Arg2& a2, const Arg3& a3, const Arg4& a4, const Arg5& a5, |
|
1675 const Arg6& a6, const Arg7& a7, const Arg8& a8, const Arg9& a9, |
|
1676 const Arg10& a10) { |
|
1677 return |
|
1678 lambda_functor_base< |
|
1679 action<10, function_action<10, Result> >, |
|
1680 typename detail::bind_tuple_mapper< |
|
1681 Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9), |
|
1682 const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, |
|
1683 const Arg7, const Arg8, const Arg9, const Arg10 |
|
1684 >::type |
|
1685 > |
|
1686 ( typename detail::bind_tuple_mapper< |
|
1687 Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9), |
|
1688 const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, |
|
1689 const Arg7, const Arg8, const Arg9, const Arg10 |
|
1690 >::type |
|
1691 (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) |
|
1692 ); |
|
1693 } |
|
1694 #endif |
|
1695 |
|
1696 #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING |
|
1697 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, |
|
1698 class Arg6, class Arg7, class Arg8, class Arg9, class Arg10> |
|
1699 inline const |
|
1700 lambda_functor< |
|
1701 lambda_functor_base< |
|
1702 action<10, function_action<10> >, |
|
1703 typename detail::bind_tuple_mapper< |
|
1704 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, |
|
1705 const Arg7, const Arg8, const Arg9, const Arg10 |
|
1706 >::type |
|
1707 > |
|
1708 > |
|
1709 |
|
1710 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
1711 const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8, |
|
1712 const Arg9& a9, const Arg10& a10) { |
|
1713 return |
|
1714 lambda_functor_base< |
|
1715 action<10, function_action<10> >, |
|
1716 typename detail::bind_tuple_mapper< |
|
1717 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, |
|
1718 const Arg6, const Arg7, const Arg8, const Arg9, const Arg10 |
|
1719 >::type |
|
1720 > |
|
1721 ( typename detail::bind_tuple_mapper< |
|
1722 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, |
|
1723 const Arg6, const Arg7, const Arg8, const Arg9, const Arg10 |
|
1724 >::type |
|
1725 (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) |
|
1726 ); |
|
1727 } |
|
1728 |
|
1729 template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, |
|
1730 class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, |
|
1731 class Arg10> |
|
1732 inline const |
|
1733 lambda_functor< |
|
1734 lambda_functor_base< |
|
1735 action<10, function_action<10, Result> >, |
|
1736 typename detail::bind_tuple_mapper< |
|
1737 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, |
|
1738 const Arg7, const Arg8, const Arg9, const Arg10 |
|
1739 >::type |
|
1740 > |
|
1741 > |
|
1742 |
|
1743 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
1744 const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8, |
|
1745 const Arg9& a9, const Arg10& a10) { |
|
1746 return |
|
1747 lambda_functor_base< |
|
1748 action<10, function_action<10, Result> >, |
|
1749 typename detail::bind_tuple_mapper< |
|
1750 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, |
|
1751 const Arg6, const Arg7, const Arg8, const Arg9, const Arg10 |
|
1752 >::type |
|
1753 > |
|
1754 ( typename detail::bind_tuple_mapper< |
|
1755 const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, |
|
1756 const Arg6, const Arg7, const Arg8, const Arg9, const Arg10 |
|
1757 >::type |
|
1758 (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) |
|
1759 ); |
|
1760 } |
|
1761 |
|
1762 |
|
1763 #else |
|
1764 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, |
|
1765 class Arg6, class Arg7, class Arg8, class Arg9, class Arg10> |
|
1766 inline const |
|
1767 lambda_functor< |
|
1768 lambda_functor_base< |
|
1769 action<10, function_action<10> >, |
|
1770 typename detail::bind_tuple_mapper< |
|
1771 typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, |
|
1772 const Arg4, const Arg5, const Arg6, const Arg7, const Arg8, const Arg9, |
|
1773 const Arg10 |
|
1774 >::type |
|
1775 > |
|
1776 > |
|
1777 |
|
1778 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
1779 const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8, |
|
1780 const Arg9& a9, const Arg10& a10) { |
|
1781 return |
|
1782 lambda_functor_base< |
|
1783 action<10, function_action<10> >, |
|
1784 typename detail::bind_tuple_mapper< |
|
1785 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
1786 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, |
|
1787 const Arg8, const Arg9, const Arg10 |
|
1788 >::type |
|
1789 > |
|
1790 ( typename detail::bind_tuple_mapper< |
|
1791 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
1792 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, |
|
1793 const Arg8, const Arg9, const Arg10 |
|
1794 >::type |
|
1795 (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) |
|
1796 ); |
|
1797 } |
|
1798 |
|
1799 template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, |
|
1800 class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, |
|
1801 class Arg10> |
|
1802 inline const |
|
1803 lambda_functor< |
|
1804 lambda_functor_base< |
|
1805 action<10, function_action<10, Result> >, |
|
1806 typename detail::bind_tuple_mapper< |
|
1807 typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, |
|
1808 const Arg4, const Arg5, const Arg6, const Arg7, const Arg8, const Arg9, |
|
1809 const Arg10 |
|
1810 >::type |
|
1811 > |
|
1812 > |
|
1813 |
|
1814 bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, |
|
1815 const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8, |
|
1816 const Arg9& a9, const Arg10& a10) { |
|
1817 return |
|
1818 lambda_functor_base< |
|
1819 action<10, function_action<10, Result> >, |
|
1820 typename detail::bind_tuple_mapper< |
|
1821 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
1822 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, |
|
1823 const Arg8, const Arg9, const Arg10 |
|
1824 >::type |
|
1825 > |
|
1826 ( typename detail::bind_tuple_mapper< |
|
1827 typename detail::constify_non_funcs<Arg1>::type, const Arg2, |
|
1828 const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, |
|
1829 const Arg8, const Arg9, const Arg10 |
|
1830 >::type |
|
1831 (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) |
|
1832 ); |
|
1833 } |
|
1834 |
|
1835 template <class Result, class Par1, class Par2, class Par3, class Par4, |
|
1836 class Par5, class Par6, class Par7, class Par8, class Par9, |
|
1837 class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, |
|
1838 class Arg7, class Arg8, class Arg9, class Arg10> |
|
1839 inline const |
|
1840 lambda_functor< |
|
1841 lambda_functor_base< |
|
1842 action<10, function_action<10, Result> >, |
|
1843 typename detail::bind_tuple_mapper< |
|
1844 Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9), |
|
1845 const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, |
|
1846 const Arg8, const Arg9, const Arg10 |
|
1847 >::type |
|
1848 > |
|
1849 > |
|
1850 |
|
1851 bind(Result(* const & a1)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, |
|
1852 Par9), const Arg2& a2, const Arg3& a3, const Arg4& a4, const Arg5& a5, |
|
1853 const Arg6& a6, const Arg7& a7, const Arg8& a8, const Arg9& a9, |
|
1854 const Arg10& a10) { |
|
1855 return |
|
1856 lambda_functor_base< |
|
1857 action<10, function_action<10, Result> >, |
|
1858 typename detail::bind_tuple_mapper< |
|
1859 Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9), |
|
1860 const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, |
|
1861 const Arg7, const Arg8, const Arg9, const Arg10 |
|
1862 >::type |
|
1863 > |
|
1864 ( typename detail::bind_tuple_mapper< |
|
1865 Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9), |
|
1866 const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, |
|
1867 const Arg7, const Arg8, const Arg9, const Arg10 |
|
1868 >::type |
|
1869 (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) |
|
1870 ); |
|
1871 } |
|
1872 |
|
1873 |
|
1874 #endif |
|
1875 |
|
1876 } // namespace lambda |
|
1877 } // namespace boost |
|
1878 |
|
1879 #endif |