1 template <
class F,
template<
class>
class P>
4 static const bool value=true ;
12 static const int value=0;
16 struct Return<R (*)()>
22 template <
class C,
class R>
23 struct Arity<R (C::*)()>
26 static const int value=0;
29 template <
class C,
class R>
30 struct Return<R (C::*)()>
36 template <
class C,
class R>
37 struct Arity<R (C::*)() const>
40 static const int value=0;
43 template <
class C,
class R>
44 struct Return<R (C::*)() const>
50 template <
class C,
class R>
51 struct is_member_function_ptr<R (C::*)()>
53 static const bool value=
true;
56 template <
class C,
class R>
57 struct is_member_function_ptr<R (C::*)() const>
59 static const bool value=
true;
62 template <
class C,
class R>
63 struct is_const_method<R (C::*)() const>
65 static const bool value=
true;
69 struct is_nonmember_function_ptr<R (*)()>
71 static const bool value=
true;
74 template <
class C,
class D,
class R>
75 class bound_method<C, R (D::*)()>
81 static const int arity=0;
83 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
84 bound_method(C& obj, M method): obj(&obj), method(method) {}
85 R operator()()
const {
return (obj->*method)();}
86 void rebind(C& newObj) {obj=&newObj;}
89 template <
class C,
class D>
90 class bound_method<C, void (D::*)()>
92 typedef void (D::*M)();
96 static const int arity=0;
98 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
99 bound_method(C& obj, M method): obj(&obj), method(method) {}
100 void operator()()
const {(obj->*method)();}
101 void rebind(C& newObj) {obj=&newObj;}
104 template <
class C,
class D,
class R>
105 class bound_method<C, R (D::*)() const>
107 typedef R (D::*M)()
const;
111 static const int arity=0;
113 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
114 bound_method(C& obj, M method): obj(obj), method(method) {}
115 R operator()()
const {
return (obj.*method)();}
118 template <
class C,
class D>
119 class bound_method<C, void (D::*)() const>
121 typedef void (D::*M)()
const;
125 static const int arity=0;
127 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
128 bound_method(C& obj, M method): obj(obj), method(method) {}
129 void operator()()
const {(obj.*method)();}
132 template <
class F,
class Args>
133 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 0> >,
134 typename Return<F>::T>::T
135 apply_nonvoid_fn(F f, Args& a, Fdummy<F> dum=0)
146 template <
class F,
class Args>
147 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 0> >,
149 apply_void_fn(F f, Args& a, Fdummy<F> dum=0)
154 template <
class R,
class A1>
155 struct Arg<R (*)(A1), 1>
158 template <
class C,
class R,
class A1>
159 struct Arg<R (C::*)(A1), 1>
162 template <
class C,
class R,
class A1>
163 struct Arg<R (C::*)(A1) const, 1>
165 template <
class F,
template<
class>
class P>
166 struct AllArgs<F,P,1>
168 static const bool value=
true && P<typename Arg<F,1>::T>::value;
172 template <
class R,
class A1>
173 struct Arity<R (*)(A1)>
175 static const int V=1;
176 static const int value=1;
179 template <
class R,
class A1>
180 struct Return<R (*)(A1)>
186 template <
class C,
class R,
class A1>
187 struct Arity<R (C::*)(A1)>
189 static const int V=1;
190 static const int value=1;
193 template <
class C,
class R,
class A1>
194 struct Return<R (C::*)(A1)>
200 template <
class C,
class R,
class A1>
201 struct Arity<R (C::*)(A1) const>
203 static const int V=1;
204 static const int value=1;
207 template <
class C,
class R,
class A1>
208 struct Return<R (C::*)(A1) const>
214 template <
class C,
class R,
class A1>
215 struct is_member_function_ptr<R (C::*)(A1)>
217 static const bool value=
true;
220 template <
class C,
class R,
class A1>
221 struct is_member_function_ptr<R (C::*)(A1) const>
223 static const bool value=
true;
226 template <
class C,
class R,
class A1>
227 struct is_const_method<R (C::*)(A1) const>
229 static const bool value=
true;
232 template <
class R,
class A1>
233 struct is_nonmember_function_ptr<R (*)(A1)>
235 static const bool value=
true;
238 template <
class C,
class D,
class R,
class A1>
239 class bound_method<C, R (D::*)(A1)>
241 typedef R (D::*M)(A1);
245 static const int arity=1;
247 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
248 bound_method(C& obj, M method): obj(&obj), method(method) {}
249 R operator()(A1 a1)
const {
return (obj->*method)(a1);}
250 void rebind(C& newObj) {obj=&newObj;}
253 template <
class C,
class D,
class A1>
254 class bound_method<C, void (D::*)(A1)>
256 typedef void (D::*M)(A1);
260 static const int arity=1;
262 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
263 bound_method(C& obj, M method): obj(&obj), method(method) {}
264 void operator()(A1 a1)
const {(obj->*method)(a1);}
265 void rebind(C& newObj) {obj=&newObj;}
268 template <
class C,
class D,
class R,
class A1>
269 class bound_method<C, R (D::*)(A1) const>
271 typedef R (D::*M)(A1)
const;
275 static const int arity=1;
277 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
278 bound_method(C& obj, M method): obj(obj), method(method) {}
279 R operator()(A1 a1)
const {
return (obj.*method)(a1);}
282 template <
class C,
class D,
class A1>
283 class bound_method<C, void (D::*)(A1) const>
285 typedef void (D::*M)(A1)
const;
289 static const int arity=1;
291 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
292 bound_method(C& obj, M method): obj(obj), method(method) {}
293 void operator()(A1 a1)
const {(obj.*method)(a1);}
296 template <
class F,
class Args>
297 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 1> >,
298 typename Return<F>::T>::T
299 apply_nonvoid_fn(F f, Args& a, Fdummy<F> dum=0)
310 template <
class F,
class Args>
311 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 1> >,
313 apply_void_fn(F f, Args& a, Fdummy<F> dum=0)
318 template <
class R,
class A1,
class A2>
319 struct Arg<R (*)(A1,A2), 1>
322 template <
class C,
class R,
class A1,
class A2>
323 struct Arg<R (C::*)(A1,A2), 1>
326 template <
class C,
class R,
class A1,
class A2>
327 struct Arg<R (C::*)(A1,A2) const, 1>
329 template <
class R,
class A1,
class A2>
330 struct Arg<R (*)(A1,A2), 2>
333 template <
class C,
class R,
class A1,
class A2>
334 struct Arg<R (C::*)(A1,A2), 2>
337 template <
class C,
class R,
class A1,
class A2>
338 struct Arg<R (C::*)(A1,A2) const, 2>
340 template <
class F,
template<
class>
class P>
341 struct AllArgs<F,P,2>
343 static const bool value=
true && P<typename Arg<F,1>::T>::value && P<typename Arg<F,2>::T>::value;
347 template <
class R,
class A1,
class A2>
348 struct Arity<R (*)(A1,A2)>
350 static const int V=2;
351 static const int value=2;
354 template <
class R,
class A1,
class A2>
355 struct Return<R (*)(A1,A2)>
361 template <
class C,
class R,
class A1,
class A2>
362 struct Arity<R (C::*)(A1,A2)>
364 static const int V=2;
365 static const int value=2;
368 template <
class C,
class R,
class A1,
class A2>
369 struct Return<R (C::*)(A1,A2)>
375 template <
class C,
class R,
class A1,
class A2>
376 struct Arity<R (C::*)(A1,A2) const>
378 static const int V=2;
379 static const int value=2;
382 template <
class C,
class R,
class A1,
class A2>
383 struct Return<R (C::*)(A1,A2) const>
389 template <
class C,
class R,
class A1,
class A2>
390 struct is_member_function_ptr<R (C::*)(A1,A2)>
392 static const bool value=
true;
395 template <
class C,
class R,
class A1,
class A2>
396 struct is_member_function_ptr<R (C::*)(A1,A2) const>
398 static const bool value=
true;
401 template <
class C,
class R,
class A1,
class A2>
402 struct is_const_method<R (C::*)(A1,A2) const>
404 static const bool value=
true;
407 template <
class R,
class A1,
class A2>
408 struct is_nonmember_function_ptr<R (*)(A1,A2)>
410 static const bool value=
true;
413 template <
class C,
class D,
class R,
class A1,
class A2>
414 class bound_method<C, R (D::*)(A1,A2)>
416 typedef R (D::*M)(A1,A2);
420 static const int arity=2;
422 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
423 bound_method(C& obj, M method): obj(&obj), method(method) {}
424 R operator()(A1 a1,A2 a2)
const {
return (obj->*method)(a1,a2);}
425 void rebind(C& newObj) {obj=&newObj;}
428 template <
class C,
class D,
class A1,
class A2>
429 class bound_method<C, void (D::*)(A1,A2)>
431 typedef void (D::*M)(A1,A2);
435 static const int arity=2;
437 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
438 bound_method(C& obj, M method): obj(&obj), method(method) {}
439 void operator()(A1 a1,A2 a2)
const {(obj->*method)(a1,a2);}
440 void rebind(C& newObj) {obj=&newObj;}
443 template <
class C,
class D,
class R,
class A1,
class A2>
444 class bound_method<C, R (D::*)(A1,A2) const>
446 typedef R (D::*M)(A1,A2)
const;
450 static const int arity=2;
452 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
453 bound_method(C& obj, M method): obj(obj), method(method) {}
454 R operator()(A1 a1,A2 a2)
const {
return (obj.*method)(a1,a2);}
457 template <
class C,
class D,
class A1,
class A2>
458 class bound_method<C, void (D::*)(A1,A2) const>
460 typedef void (D::*M)(A1,A2)
const;
464 static const int arity=2;
466 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
467 bound_method(C& obj, M method): obj(obj), method(method) {}
468 void operator()(A1 a1,A2 a2)
const {(obj.*method)(a1,a2);}
471 template <
class F,
class Args>
472 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 2> >,
473 typename Return<F>::T>::T
474 apply_nonvoid_fn(F f, Args& a, Fdummy<F> dum=0)
485 template <
class F,
class Args>
486 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 2> >,
488 apply_void_fn(F f, Args& a, Fdummy<F> dum=0)
493 template <
class R,
class A1,
class A2,
class A3>
494 struct Arg<R (*)(A1,A2,A3), 1>
497 template <
class C,
class R,
class A1,
class A2,
class A3>
498 struct Arg<R (C::*)(A1,A2,A3), 1>
501 template <
class C,
class R,
class A1,
class A2,
class A3>
502 struct Arg<R (C::*)(A1,A2,A3) const, 1>
504 template <
class R,
class A1,
class A2,
class A3>
505 struct Arg<R (*)(A1,A2,A3), 2>
508 template <
class C,
class R,
class A1,
class A2,
class A3>
509 struct Arg<R (C::*)(A1,A2,A3), 2>
512 template <
class C,
class R,
class A1,
class A2,
class A3>
513 struct Arg<R (C::*)(A1,A2,A3) const, 2>
515 template <
class R,
class A1,
class A2,
class A3>
516 struct Arg<R (*)(A1,A2,A3), 3>
519 template <
class C,
class R,
class A1,
class A2,
class A3>
520 struct Arg<R (C::*)(A1,A2,A3), 3>
523 template <
class C,
class R,
class A1,
class A2,
class A3>
524 struct Arg<R (C::*)(A1,A2,A3) const, 3>
526 template <
class F,
template<
class>
class P>
527 struct AllArgs<F,P,3>
529 static const bool value=
true && P<typename Arg<F,1>::T>::value && P<typename Arg<F,2>::T>::value && P<typename Arg<F,3>::T>::value;
533 template <
class R,
class A1,
class A2,
class A3>
534 struct Arity<R (*)(A1,A2,A3)>
536 static const int V=3;
537 static const int value=3;
540 template <
class R,
class A1,
class A2,
class A3>
541 struct Return<R (*)(A1,A2,A3)>
547 template <
class C,
class R,
class A1,
class A2,
class A3>
548 struct Arity<R (C::*)(A1,A2,A3)>
550 static const int V=3;
551 static const int value=3;
554 template <
class C,
class R,
class A1,
class A2,
class A3>
555 struct Return<R (C::*)(A1,A2,A3)>
561 template <
class C,
class R,
class A1,
class A2,
class A3>
562 struct Arity<R (C::*)(A1,A2,A3) const>
564 static const int V=3;
565 static const int value=3;
568 template <
class C,
class R,
class A1,
class A2,
class A3>
569 struct Return<R (C::*)(A1,A2,A3) const>
575 template <
class C,
class R,
class A1,
class A2,
class A3>
576 struct is_member_function_ptr<R (C::*)(A1,A2,A3)>
578 static const bool value=
true;
581 template <
class C,
class R,
class A1,
class A2,
class A3>
582 struct is_member_function_ptr<R (C::*)(A1,A2,A3) const>
584 static const bool value=
true;
587 template <
class C,
class R,
class A1,
class A2,
class A3>
588 struct is_const_method<R (C::*)(A1,A2,A3) const>
590 static const bool value=
true;
593 template <
class R,
class A1,
class A2,
class A3>
594 struct is_nonmember_function_ptr<R (*)(A1,A2,A3)>
596 static const bool value=
true;
599 template <
class C,
class D,
class R,
class A1,
class A2,
class A3>
600 class bound_method<C, R (D::*)(A1,A2,A3)>
602 typedef R (D::*M)(A1,A2,A3);
606 static const int arity=3;
608 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
609 bound_method(C& obj, M method): obj(&obj), method(method) {}
610 R operator()(A1 a1,A2 a2,A3 a3)
const {
return (obj->*method)(a1,a2,a3);}
611 void rebind(C& newObj) {obj=&newObj;}
614 template <
class C,
class D,
class A1,
class A2,
class A3>
615 class bound_method<C, void (D::*)(A1,A2,A3)>
617 typedef void (D::*M)(A1,A2,A3);
621 static const int arity=3;
623 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
624 bound_method(C& obj, M method): obj(&obj), method(method) {}
625 void operator()(A1 a1,A2 a2,A3 a3)
const {(obj->*method)(a1,a2,a3);}
626 void rebind(C& newObj) {obj=&newObj;}
629 template <
class C,
class D,
class R,
class A1,
class A2,
class A3>
630 class bound_method<C, R (D::*)(A1,A2,A3) const>
632 typedef R (D::*M)(A1,A2,A3)
const;
636 static const int arity=3;
638 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
639 bound_method(C& obj, M method): obj(obj), method(method) {}
640 R operator()(A1 a1,A2 a2,A3 a3)
const {
return (obj.*method)(a1,a2,a3);}
643 template <
class C,
class D,
class A1,
class A2,
class A3>
644 class bound_method<C, void (D::*)(A1,A2,A3) const>
646 typedef void (D::*M)(A1,A2,A3)
const;
650 static const int arity=3;
652 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
653 bound_method(C& obj, M method): obj(obj), method(method) {}
654 void operator()(A1 a1,A2 a2,A3 a3)
const {(obj.*method)(a1,a2,a3);}
657 template <
class F,
class Args>
658 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 3> >,
659 typename Return<F>::T>::T
660 apply_nonvoid_fn(F f, Args& a, Fdummy<F> dum=0)
662 return f(a[0],a[1],a[2]);
671 template <
class F,
class Args>
672 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 3> >,
674 apply_void_fn(F f, Args& a, Fdummy<F> dum=0)
679 template <
class R,
class A1,
class A2,
class A3,
class A4>
680 struct Arg<R (*)(A1,A2,A3,A4), 1>
683 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4>
684 struct Arg<R (C::*)(A1,A2,A3,A4), 1>
687 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4>
688 struct Arg<R (C::*)(A1,A2,A3,A4) const, 1>
690 template <
class R,
class A1,
class A2,
class A3,
class A4>
691 struct Arg<R (*)(A1,A2,A3,A4), 2>
694 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4>
695 struct Arg<R (C::*)(A1,A2,A3,A4), 2>
698 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4>
699 struct Arg<R (C::*)(A1,A2,A3,A4) const, 2>
701 template <
class R,
class A1,
class A2,
class A3,
class A4>
702 struct Arg<R (*)(A1,A2,A3,A4), 3>
705 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4>
706 struct Arg<R (C::*)(A1,A2,A3,A4), 3>
709 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4>
710 struct Arg<R (C::*)(A1,A2,A3,A4) const, 3>
712 template <
class R,
class A1,
class A2,
class A3,
class A4>
713 struct Arg<R (*)(A1,A2,A3,A4), 4>
716 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4>
717 struct Arg<R (C::*)(A1,A2,A3,A4), 4>
720 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4>
721 struct Arg<R (C::*)(A1,A2,A3,A4) const, 4>
723 template <
class F,
template<
class>
class P>
724 struct AllArgs<F,P,4>
726 static const bool value=
true && P<typename Arg<F,1>::T>::value && P<typename Arg<F,2>::T>::value && P<typename Arg<F,3>::T>::value && P<typename Arg<F,4>::T>::value;
730 template <
class R,
class A1,
class A2,
class A3,
class A4>
731 struct Arity<R (*)(A1,A2,A3,A4)>
733 static const int V=4;
734 static const int value=4;
737 template <
class R,
class A1,
class A2,
class A3,
class A4>
738 struct Return<R (*)(A1,A2,A3,A4)>
744 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4>
745 struct Arity<R (C::*)(A1,A2,A3,A4)>
747 static const int V=4;
748 static const int value=4;
751 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4>
752 struct Return<R (C::*)(A1,A2,A3,A4)>
758 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4>
759 struct Arity<R (C::*)(A1,A2,A3,A4) const>
761 static const int V=4;
762 static const int value=4;
765 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4>
766 struct Return<R (C::*)(A1,A2,A3,A4) const>
772 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4>
773 struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4)>
775 static const bool value=
true;
778 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4>
779 struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4) const>
781 static const bool value=
true;
784 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4>
785 struct is_const_method<R (C::*)(A1,A2,A3,A4) const>
787 static const bool value=
true;
790 template <
class R,
class A1,
class A2,
class A3,
class A4>
791 struct is_nonmember_function_ptr<R (*)(A1,A2,A3,A4)>
793 static const bool value=
true;
796 template <
class C,
class D,
class R,
class A1,
class A2,
class A3,
class A4>
797 class bound_method<C, R (D::*)(A1,A2,A3,A4)>
799 typedef R (D::*M)(A1,A2,A3,A4);
803 static const int arity=4;
805 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
806 bound_method(C& obj, M method): obj(&obj), method(method) {}
807 R operator()(A1 a1,A2 a2,A3 a3,A4 a4)
const {
return (obj->*method)(a1,a2,a3,a4);}
808 void rebind(C& newObj) {obj=&newObj;}
811 template <
class C,
class D,
class A1,
class A2,
class A3,
class A4>
812 class bound_method<C, void (D::*)(A1,A2,A3,A4)>
814 typedef void (D::*M)(A1,A2,A3,A4);
818 static const int arity=4;
820 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
821 bound_method(C& obj, M method): obj(&obj), method(method) {}
822 void operator()(A1 a1,A2 a2,A3 a3,A4 a4)
const {(obj->*method)(a1,a2,a3,a4);}
823 void rebind(C& newObj) {obj=&newObj;}
826 template <
class C,
class D,
class R,
class A1,
class A2,
class A3,
class A4>
827 class bound_method<C, R (D::*)(A1,A2,A3,A4) const>
829 typedef R (D::*M)(A1,A2,A3,A4)
const;
833 static const int arity=4;
835 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
836 bound_method(C& obj, M method): obj(obj), method(method) {}
837 R operator()(A1 a1,A2 a2,A3 a3,A4 a4)
const {
return (obj.*method)(a1,a2,a3,a4);}
840 template <
class C,
class D,
class A1,
class A2,
class A3,
class A4>
841 class bound_method<C, void (D::*)(A1,A2,A3,A4) const>
843 typedef void (D::*M)(A1,A2,A3,A4)
const;
847 static const int arity=4;
849 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
850 bound_method(C& obj, M method): obj(obj), method(method) {}
851 void operator()(A1 a1,A2 a2,A3 a3,A4 a4)
const {(obj.*method)(a1,a2,a3,a4);}
854 template <
class F,
class Args>
855 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 4> >,
856 typename Return<F>::T>::T
857 apply_nonvoid_fn(F f, Args& a, Fdummy<F> dum=0)
859 return f(a[0],a[1],a[2],a[3]);
868 template <
class F,
class Args>
869 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 4> >,
871 apply_void_fn(F f, Args& a, Fdummy<F> dum=0)
873 f(a[0],a[1],a[2],a[3]);
876 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
877 struct Arg<R (*)(A1,A2,A3,A4,A5), 1>
880 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
881 struct Arg<R (C::*)(A1,A2,A3,A4,A5), 1>
884 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
885 struct Arg<R (C::*)(A1,A2,A3,A4,A5) const, 1>
887 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
888 struct Arg<R (*)(A1,A2,A3,A4,A5), 2>
891 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
892 struct Arg<R (C::*)(A1,A2,A3,A4,A5), 2>
895 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
896 struct Arg<R (C::*)(A1,A2,A3,A4,A5) const, 2>
898 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
899 struct Arg<R (*)(A1,A2,A3,A4,A5), 3>
902 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
903 struct Arg<R (C::*)(A1,A2,A3,A4,A5), 3>
906 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
907 struct Arg<R (C::*)(A1,A2,A3,A4,A5) const, 3>
909 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
910 struct Arg<R (*)(A1,A2,A3,A4,A5), 4>
913 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
914 struct Arg<R (C::*)(A1,A2,A3,A4,A5), 4>
917 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
918 struct Arg<R (C::*)(A1,A2,A3,A4,A5) const, 4>
920 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
921 struct Arg<R (*)(A1,A2,A3,A4,A5), 5>
924 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
925 struct Arg<R (C::*)(A1,A2,A3,A4,A5), 5>
928 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
929 struct Arg<R (C::*)(A1,A2,A3,A4,A5) const, 5>
931 template <
class F,
template<
class>
class P>
932 struct AllArgs<F,P,5>
934 static const bool value=
true && P<typename Arg<F,1>::T>::value && P<typename Arg<F,2>::T>::value && P<typename Arg<F,3>::T>::value && P<typename Arg<F,4>::T>::value && P<typename Arg<F,5>::T>::value;
938 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
939 struct Arity<R (*)(A1,A2,A3,A4,A5)>
941 static const int V=5;
942 static const int value=5;
945 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
946 struct Return<R (*)(A1,A2,A3,A4,A5)>
952 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
953 struct Arity<R (C::*)(A1,A2,A3,A4,A5)>
955 static const int V=5;
956 static const int value=5;
959 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
960 struct Return<R (C::*)(A1,A2,A3,A4,A5)>
966 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
967 struct Arity<R (C::*)(A1,A2,A3,A4,A5) const>
969 static const int V=5;
970 static const int value=5;
973 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
974 struct Return<R (C::*)(A1,A2,A3,A4,A5) const>
980 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
981 struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4,A5)>
983 static const bool value=
true;
986 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
987 struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4,A5) const>
989 static const bool value=
true;
992 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
993 struct is_const_method<R (C::*)(A1,A2,A3,A4,A5) const>
995 static const bool value=
true;
998 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
999 struct is_nonmember_function_ptr<R (*)(A1,A2,A3,A4,A5)>
1001 static const bool value=
true;
1004 template <
class C,
class D,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
1005 class bound_method<C, R (D::*)(A1,A2,A3,A4,A5)>
1007 typedef R (D::*M)(A1,A2,A3,A4,A5);
1011 static const int arity=5;
1013 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1014 bound_method(C& obj, M method): obj(&obj), method(method) {}
1015 R operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5)
const {
return (obj->*method)(a1,a2,a3,a4,a5);}
1016 void rebind(C& newObj) {obj=&newObj;}
1019 template <
class C,
class D,
class A1,
class A2,
class A3,
class A4,
class A5>
1020 class bound_method<C, void (D::*)(A1,A2,A3,A4,A5)>
1022 typedef void (D::*M)(A1,A2,A3,A4,A5);
1026 static const int arity=5;
1028 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1029 bound_method(C& obj, M method): obj(&obj), method(method) {}
1030 void operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5)
const {(obj->*method)(a1,a2,a3,a4,a5);}
1031 void rebind(C& newObj) {obj=&newObj;}
1034 template <
class C,
class D,
class R,
class A1,
class A2,
class A3,
class A4,
class A5>
1035 class bound_method<C, R (D::*)(A1,A2,A3,A4,A5) const>
1037 typedef R (D::*M)(A1,A2,A3,A4,A5)
const;
1041 static const int arity=5;
1043 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1044 bound_method(C& obj, M method): obj(obj), method(method) {}
1045 R operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5)
const {
return (obj.*method)(a1,a2,a3,a4,a5);}
1048 template <
class C,
class D,
class A1,
class A2,
class A3,
class A4,
class A5>
1049 class bound_method<C, void (D::*)(A1,A2,A3,A4,A5) const>
1051 typedef void (D::*M)(A1,A2,A3,A4,A5)
const;
1055 static const int arity=5;
1057 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1058 bound_method(C& obj, M method): obj(obj), method(method) {}
1059 void operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5)
const {(obj.*method)(a1,a2,a3,a4,a5);}
1062 template <
class F,
class Args>
1063 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 5> >,
1064 typename Return<F>::T>::T
1065 apply_nonvoid_fn(F f, Args& a, Fdummy<F> dum=0)
1067 return f(a[0],a[1],a[2],a[3],a[4]);
1076 template <
class F,
class Args>
1077 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 5> >,
1079 apply_void_fn(F f, Args& a, Fdummy<F> dum=0)
1081 f(a[0],a[1],a[2],a[3],a[4]);
1084 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1085 struct Arg<R (*)(A1,A2,A3,A4,A5,A6), 1>
1088 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1089 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6), 1>
1092 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1093 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6) const, 1>
1095 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1096 struct Arg<R (*)(A1,A2,A3,A4,A5,A6), 2>
1099 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1100 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6), 2>
1103 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1104 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6) const, 2>
1106 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1107 struct Arg<R (*)(A1,A2,A3,A4,A5,A6), 3>
1110 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1111 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6), 3>
1114 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1115 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6) const, 3>
1117 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1118 struct Arg<R (*)(A1,A2,A3,A4,A5,A6), 4>
1121 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1122 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6), 4>
1125 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1126 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6) const, 4>
1128 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1129 struct Arg<R (*)(A1,A2,A3,A4,A5,A6), 5>
1132 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1133 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6), 5>
1136 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1137 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6) const, 5>
1139 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1140 struct Arg<R (*)(A1,A2,A3,A4,A5,A6), 6>
1143 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1144 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6), 6>
1147 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1148 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6) const, 6>
1150 template <
class F,
template<
class>
class P>
1151 struct AllArgs<F,P,6>
1153 static const bool value=
true && P<typename Arg<F,1>::T>::value && P<typename Arg<F,2>::T>::value && P<typename Arg<F,3>::T>::value && P<typename Arg<F,4>::T>::value && P<typename Arg<F,5>::T>::value && P<typename Arg<F,6>::T>::value;
1157 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1158 struct Arity<R (*)(A1,A2,A3,A4,A5,A6)>
1160 static const int V=6;
1161 static const int value=6;
1164 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1165 struct Return<R (*)(A1,A2,A3,A4,A5,A6)>
1171 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1172 struct Arity<R (C::*)(A1,A2,A3,A4,A5,A6)>
1174 static const int V=6;
1175 static const int value=6;
1178 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1179 struct Return<R (C::*)(A1,A2,A3,A4,A5,A6)>
1185 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1186 struct Arity<R (C::*)(A1,A2,A3,A4,A5,A6) const>
1188 static const int V=6;
1189 static const int value=6;
1192 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1193 struct Return<R (C::*)(A1,A2,A3,A4,A5,A6) const>
1199 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1200 struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4,A5,A6)>
1202 static const bool value=
true;
1205 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1206 struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4,A5,A6) const>
1208 static const bool value=
true;
1211 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1212 struct is_const_method<R (C::*)(A1,A2,A3,A4,A5,A6) const>
1214 static const bool value=
true;
1217 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1218 struct is_nonmember_function_ptr<R (*)(A1,A2,A3,A4,A5,A6)>
1220 static const bool value=
true;
1223 template <
class C,
class D,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1224 class bound_method<C, R (D::*)(A1,A2,A3,A4,A5,A6)>
1226 typedef R (D::*M)(A1,A2,A3,A4,A5,A6);
1230 static const int arity=6;
1232 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1233 bound_method(C& obj, M method): obj(&obj), method(method) {}
1234 R operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6)
const {
return (obj->*method)(a1,a2,a3,a4,a5,a6);}
1235 void rebind(C& newObj) {obj=&newObj;}
1238 template <
class C,
class D,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1239 class bound_method<C, void (D::*)(A1,A2,A3,A4,A5,A6)>
1241 typedef void (D::*M)(A1,A2,A3,A4,A5,A6);
1245 static const int arity=6;
1247 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1248 bound_method(C& obj, M method): obj(&obj), method(method) {}
1249 void operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6)
const {(obj->*method)(a1,a2,a3,a4,a5,a6);}
1250 void rebind(C& newObj) {obj=&newObj;}
1253 template <
class C,
class D,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1254 class bound_method<C, R (D::*)(A1,A2,A3,A4,A5,A6) const>
1256 typedef R (D::*M)(A1,A2,A3,A4,A5,A6)
const;
1260 static const int arity=6;
1262 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1263 bound_method(C& obj, M method): obj(obj), method(method) {}
1264 R operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6)
const {
return (obj.*method)(a1,a2,a3,a4,a5,a6);}
1267 template <
class C,
class D,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6>
1268 class bound_method<C, void (D::*)(A1,A2,A3,A4,A5,A6) const>
1270 typedef void (D::*M)(A1,A2,A3,A4,A5,A6)
const;
1274 static const int arity=6;
1276 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1277 bound_method(C& obj, M method): obj(obj), method(method) {}
1278 void operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6)
const {(obj.*method)(a1,a2,a3,a4,a5,a6);}
1281 template <
class F,
class Args>
1282 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 6> >,
1283 typename Return<F>::T>::T
1284 apply_nonvoid_fn(F f, Args& a, Fdummy<F> dum=0)
1286 return f(a[0],a[1],a[2],a[3],a[4],a[5]);
1295 template <
class F,
class Args>
1296 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 6> >,
1298 apply_void_fn(F f, Args& a, Fdummy<F> dum=0)
1300 f(a[0],a[1],a[2],a[3],a[4],a[5]);
1303 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1304 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7), 1>
1307 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1308 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7), 1>
1311 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1312 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7) const, 1>
1314 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1315 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7), 2>
1318 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1319 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7), 2>
1322 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1323 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7) const, 2>
1325 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1326 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7), 3>
1329 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1330 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7), 3>
1333 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1334 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7) const, 3>
1336 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1337 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7), 4>
1340 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1341 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7), 4>
1344 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1345 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7) const, 4>
1347 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1348 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7), 5>
1351 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1352 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7), 5>
1355 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1356 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7) const, 5>
1358 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1359 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7), 6>
1362 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1363 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7), 6>
1366 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1367 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7) const, 6>
1369 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1370 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7), 7>
1373 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1374 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7), 7>
1377 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1378 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7) const, 7>
1380 template <
class F,
template<
class>
class P>
1381 struct AllArgs<F,P,7>
1383 static const bool value=
true && P<typename Arg<F,1>::T>::value && P<typename Arg<F,2>::T>::value && P<typename Arg<F,3>::T>::value && P<typename Arg<F,4>::T>::value && P<typename Arg<F,5>::T>::value && P<typename Arg<F,6>::T>::value && P<typename Arg<F,7>::T>::value;
1387 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1388 struct Arity<R (*)(A1,A2,A3,A4,A5,A6,A7)>
1390 static const int V=7;
1391 static const int value=7;
1394 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1395 struct Return<R (*)(A1,A2,A3,A4,A5,A6,A7)>
1401 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1402 struct Arity<R (C::*)(A1,A2,A3,A4,A5,A6,A7)>
1404 static const int V=7;
1405 static const int value=7;
1408 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1409 struct Return<R (C::*)(A1,A2,A3,A4,A5,A6,A7)>
1415 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1416 struct Arity<R (C::*)(A1,A2,A3,A4,A5,A6,A7) const>
1418 static const int V=7;
1419 static const int value=7;
1422 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1423 struct Return<R (C::*)(A1,A2,A3,A4,A5,A6,A7) const>
1429 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1430 struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4,A5,A6,A7)>
1432 static const bool value=
true;
1435 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1436 struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4,A5,A6,A7) const>
1438 static const bool value=
true;
1441 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1442 struct is_const_method<R (C::*)(A1,A2,A3,A4,A5,A6,A7) const>
1444 static const bool value=
true;
1447 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1448 struct is_nonmember_function_ptr<R (*)(A1,A2,A3,A4,A5,A6,A7)>
1450 static const bool value=
true;
1453 template <
class C,
class D,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1454 class bound_method<C, R (D::*)(A1,A2,A3,A4,A5,A6,A7)>
1456 typedef R (D::*M)(A1,A2,A3,A4,A5,A6,A7);
1460 static const int arity=7;
1462 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1463 bound_method(C& obj, M method): obj(&obj), method(method) {}
1464 R operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7)
const {
return (obj->*method)(a1,a2,a3,a4,a5,a6,a7);}
1465 void rebind(C& newObj) {obj=&newObj;}
1468 template <
class C,
class D,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1469 class bound_method<C, void (D::*)(A1,A2,A3,A4,A5,A6,A7)>
1471 typedef void (D::*M)(A1,A2,A3,A4,A5,A6,A7);
1475 static const int arity=7;
1477 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1478 bound_method(C& obj, M method): obj(&obj), method(method) {}
1479 void operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7)
const {(obj->*method)(a1,a2,a3,a4,a5,a6,a7);}
1480 void rebind(C& newObj) {obj=&newObj;}
1483 template <
class C,
class D,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1484 class bound_method<C, R (D::*)(A1,A2,A3,A4,A5,A6,A7) const>
1486 typedef R (D::*M)(A1,A2,A3,A4,A5,A6,A7)
const;
1490 static const int arity=7;
1492 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1493 bound_method(C& obj, M method): obj(obj), method(method) {}
1494 R operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7)
const {
return (obj.*method)(a1,a2,a3,a4,a5,a6,a7);}
1497 template <
class C,
class D,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7>
1498 class bound_method<C, void (D::*)(A1,A2,A3,A4,A5,A6,A7) const>
1500 typedef void (D::*M)(A1,A2,A3,A4,A5,A6,A7)
const;
1504 static const int arity=7;
1506 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1507 bound_method(C& obj, M method): obj(obj), method(method) {}
1508 void operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7)
const {(obj.*method)(a1,a2,a3,a4,a5,a6,a7);}
1511 template <
class F,
class Args>
1512 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 7> >,
1513 typename Return<F>::T>::T
1514 apply_nonvoid_fn(F f, Args& a, Fdummy<F> dum=0)
1516 return f(a[0],a[1],a[2],a[3],a[4],a[5],a[6]);
1525 template <
class F,
class Args>
1526 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 7> >,
1528 apply_void_fn(F f, Args& a, Fdummy<F> dum=0)
1530 f(a[0],a[1],a[2],a[3],a[4],a[5],a[6]);
1533 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1534 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8), 1>
1537 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1538 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8), 1>
1541 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1542 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8) const, 1>
1544 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1545 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8), 2>
1548 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1549 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8), 2>
1552 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1553 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8) const, 2>
1555 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1556 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8), 3>
1559 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1560 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8), 3>
1563 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1564 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8) const, 3>
1566 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1567 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8), 4>
1570 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1571 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8), 4>
1574 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1575 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8) const, 4>
1577 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1578 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8), 5>
1581 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1582 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8), 5>
1585 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1586 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8) const, 5>
1588 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1589 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8), 6>
1592 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1593 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8), 6>
1596 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1597 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8) const, 6>
1599 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1600 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8), 7>
1603 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1604 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8), 7>
1607 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1608 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8) const, 7>
1610 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1611 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8), 8>
1614 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1615 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8), 8>
1618 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1619 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8) const, 8>
1621 template <
class F,
template<
class>
class P>
1622 struct AllArgs<F,P,8>
1624 static const bool value=
true && P<typename Arg<F,1>::T>::value && P<typename Arg<F,2>::T>::value && P<typename Arg<F,3>::T>::value && P<typename Arg<F,4>::T>::value && P<typename Arg<F,5>::T>::value && P<typename Arg<F,6>::T>::value && P<typename Arg<F,7>::T>::value && P<typename Arg<F,8>::T>::value;
1628 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1629 struct Arity<R (*)(A1,A2,A3,A4,A5,A6,A7,A8)>
1631 static const int V=8;
1632 static const int value=8;
1635 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1636 struct Return<R (*)(A1,A2,A3,A4,A5,A6,A7,A8)>
1642 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1643 struct Arity<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8)>
1645 static const int V=8;
1646 static const int value=8;
1649 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1650 struct Return<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8)>
1656 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1657 struct Arity<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8) const>
1659 static const int V=8;
1660 static const int value=8;
1663 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1664 struct Return<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8) const>
1670 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1671 struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8)>
1673 static const bool value=
true;
1676 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1677 struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8) const>
1679 static const bool value=
true;
1682 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1683 struct is_const_method<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8) const>
1685 static const bool value=
true;
1688 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1689 struct is_nonmember_function_ptr<R (*)(A1,A2,A3,A4,A5,A6,A7,A8)>
1691 static const bool value=
true;
1694 template <
class C,
class D,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1695 class bound_method<C, R (D::*)(A1,A2,A3,A4,A5,A6,A7,A8)>
1697 typedef R (D::*M)(A1,A2,A3,A4,A5,A6,A7,A8);
1701 static const int arity=8;
1703 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1704 bound_method(C& obj, M method): obj(&obj), method(method) {}
1705 R operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8)
const {
return (obj->*method)(a1,a2,a3,a4,a5,a6,a7,a8);}
1706 void rebind(C& newObj) {obj=&newObj;}
1709 template <
class C,
class D,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1710 class bound_method<C, void (D::*)(A1,A2,A3,A4,A5,A6,A7,A8)>
1712 typedef void (D::*M)(A1,A2,A3,A4,A5,A6,A7,A8);
1716 static const int arity=8;
1718 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1719 bound_method(C& obj, M method): obj(&obj), method(method) {}
1720 void operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8)
const {(obj->*method)(a1,a2,a3,a4,a5,a6,a7,a8);}
1721 void rebind(C& newObj) {obj=&newObj;}
1724 template <
class C,
class D,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1725 class bound_method<C, R (D::*)(A1,A2,A3,A4,A5,A6,A7,A8) const>
1727 typedef R (D::*M)(A1,A2,A3,A4,A5,A6,A7,A8)
const;
1731 static const int arity=8;
1733 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1734 bound_method(C& obj, M method): obj(obj), method(method) {}
1735 R operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8)
const {
return (obj.*method)(a1,a2,a3,a4,a5,a6,a7,a8);}
1738 template <
class C,
class D,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8>
1739 class bound_method<C, void (D::*)(A1,A2,A3,A4,A5,A6,A7,A8) const>
1741 typedef void (D::*M)(A1,A2,A3,A4,A5,A6,A7,A8)
const;
1745 static const int arity=8;
1747 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1748 bound_method(C& obj, M method): obj(obj), method(method) {}
1749 void operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8)
const {(obj.*method)(a1,a2,a3,a4,a5,a6,a7,a8);}
1752 template <
class F,
class Args>
1753 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 8> >,
1754 typename Return<F>::T>::T
1755 apply_nonvoid_fn(F f, Args& a, Fdummy<F> dum=0)
1757 return f(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]);
1766 template <
class F,
class Args>
1767 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 8> >,
1769 apply_void_fn(F f, Args& a, Fdummy<F> dum=0)
1771 f(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]);
1774 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1775 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9), 1>
1778 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1779 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9), 1>
1782 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1783 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9) const, 1>
1785 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1786 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9), 2>
1789 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1790 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9), 2>
1793 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1794 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9) const, 2>
1796 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1797 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9), 3>
1800 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1801 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9), 3>
1804 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1805 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9) const, 3>
1807 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1808 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9), 4>
1811 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1812 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9), 4>
1815 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1816 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9) const, 4>
1818 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1819 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9), 5>
1822 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1823 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9), 5>
1826 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1827 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9) const, 5>
1829 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1830 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9), 6>
1833 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1834 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9), 6>
1837 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1838 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9) const, 6>
1840 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1841 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9), 7>
1844 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1845 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9), 7>
1848 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1849 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9) const, 7>
1851 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1852 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9), 8>
1855 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1856 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9), 8>
1859 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1860 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9) const, 8>
1862 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1863 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9), 9>
1866 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1867 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9), 9>
1870 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1871 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9) const, 9>
1873 template <
class F,
template<
class>
class P>
1874 struct AllArgs<F,P,9>
1876 static const bool value=
true && P<typename Arg<F,1>::T>::value && P<typename Arg<F,2>::T>::value && P<typename Arg<F,3>::T>::value && P<typename Arg<F,4>::T>::value && P<typename Arg<F,5>::T>::value && P<typename Arg<F,6>::T>::value && P<typename Arg<F,7>::T>::value && P<typename Arg<F,8>::T>::value && P<typename Arg<F,9>::T>::value;
1880 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1881 struct Arity<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9)>
1883 static const int V=9;
1884 static const int value=9;
1887 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1888 struct Return<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9)>
1894 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1895 struct Arity<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9)>
1897 static const int V=9;
1898 static const int value=9;
1901 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1902 struct Return<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9)>
1908 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1909 struct Arity<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9) const>
1911 static const int V=9;
1912 static const int value=9;
1915 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1916 struct Return<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9) const>
1922 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1923 struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9)>
1925 static const bool value=
true;
1928 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1929 struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9) const>
1931 static const bool value=
true;
1934 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1935 struct is_const_method<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9) const>
1937 static const bool value=
true;
1940 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1941 struct is_nonmember_function_ptr<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9)>
1943 static const bool value=
true;
1946 template <
class C,
class D,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1947 class bound_method<C, R (D::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9)>
1949 typedef R (D::*M)(A1,A2,A3,A4,A5,A6,A7,A8,A9);
1953 static const int arity=9;
1955 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1956 bound_method(C& obj, M method): obj(&obj), method(method) {}
1957 R operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9)
const {
return (obj->*method)(a1,a2,a3,a4,a5,a6,a7,a8,a9);}
1958 void rebind(C& newObj) {obj=&newObj;}
1961 template <
class C,
class D,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1962 class bound_method<C, void (D::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9)>
1964 typedef void (D::*M)(A1,A2,A3,A4,A5,A6,A7,A8,A9);
1968 static const int arity=9;
1970 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1971 bound_method(C& obj, M method): obj(&obj), method(method) {}
1972 void operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9)
const {(obj->*method)(a1,a2,a3,a4,a5,a6,a7,a8,a9);}
1973 void rebind(C& newObj) {obj=&newObj;}
1976 template <
class C,
class D,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1977 class bound_method<C, R (D::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9) const>
1979 typedef R (D::*M)(A1,A2,A3,A4,A5,A6,A7,A8,A9)
const;
1983 static const int arity=9;
1985 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
1986 bound_method(C& obj, M method): obj(obj), method(method) {}
1987 R operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9)
const {
return (obj.*method)(a1,a2,a3,a4,a5,a6,a7,a8,a9);}
1990 template <
class C,
class D,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9>
1991 class bound_method<C, void (D::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9) const>
1993 typedef void (D::*M)(A1,A2,A3,A4,A5,A6,A7,A8,A9)
const;
1997 static const int arity=9;
1999 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
2000 bound_method(C& obj, M method): obj(obj), method(method) {}
2001 void operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9)
const {(obj.*method)(a1,a2,a3,a4,a5,a6,a7,a8,a9);}
2004 template <
class F,
class Args>
2005 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 9> >,
2006 typename Return<F>::T>::T
2007 apply_nonvoid_fn(F f, Args& a, Fdummy<F> dum=0)
2009 return f(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8]);
2018 template <
class F,
class Args>
2019 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 9> >,
2021 apply_void_fn(F f, Args& a, Fdummy<F> dum=0)
2023 f(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8]);
2026 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2027 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 1>
2030 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2031 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 1>
2034 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2035 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) const, 1>
2037 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2038 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 2>
2041 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2042 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 2>
2045 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2046 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) const, 2>
2048 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2049 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 3>
2052 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2053 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 3>
2056 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2057 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) const, 3>
2059 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2060 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 4>
2063 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2064 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 4>
2067 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2068 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) const, 4>
2070 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2071 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 5>
2074 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2075 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 5>
2078 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2079 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) const, 5>
2081 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2082 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 6>
2085 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2086 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 6>
2089 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2090 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) const, 6>
2092 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2093 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 7>
2096 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2097 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 7>
2100 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2101 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) const, 7>
2103 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2104 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 8>
2107 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2108 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 8>
2111 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2112 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) const, 8>
2114 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2115 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 9>
2118 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2119 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 9>
2122 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2123 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) const, 9>
2125 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2126 struct Arg<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 10>
2129 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2130 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10), 10>
2133 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2134 struct Arg<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) const, 10>
2136 template <
class F,
template<
class>
class P>
2137 struct AllArgs<F,P,10>
2139 static const bool value=
true && P<typename Arg<F,1>::T>::value && P<typename Arg<F,2>::T>::value && P<typename Arg<F,3>::T>::value && P<typename Arg<F,4>::T>::value && P<typename Arg<F,5>::T>::value && P<typename Arg<F,6>::T>::value && P<typename Arg<F,7>::T>::value && P<typename Arg<F,8>::T>::value && P<typename Arg<F,9>::T>::value && P<typename Arg<F,10>::T>::value;
2143 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2144 struct Arity<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)>
2146 static const int V=10;
2147 static const int value=10;
2150 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2151 struct Return<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)>
2157 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2158 struct Arity<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)>
2160 static const int V=10;
2161 static const int value=10;
2164 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2165 struct Return<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)>
2171 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2172 struct Arity<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) const>
2174 static const int V=10;
2175 static const int value=10;
2178 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2179 struct Return<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) const>
2185 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2186 struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)>
2188 static const bool value=
true;
2191 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2192 struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) const>
2194 static const bool value=
true;
2197 template <
class C,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2198 struct is_const_method<R (C::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) const>
2200 static const bool value=
true;
2203 template <
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2204 struct is_nonmember_function_ptr<R (*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)>
2206 static const bool value=
true;
2209 template <
class C,
class D,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2210 class bound_method<C, R (D::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)>
2212 typedef R (D::*M)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10);
2216 static const int arity=10;
2218 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
2219 bound_method(C& obj, M method): obj(&obj), method(method) {}
2220 R operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9,A10 a10)
const {
return (obj->*method)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10);}
2221 void rebind(C& newObj) {obj=&newObj;}
2224 template <
class C,
class D,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2225 class bound_method<C, void (D::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)>
2227 typedef void (D::*M)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10);
2231 static const int arity=10;
2233 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
2234 bound_method(C& obj, M method): obj(&obj), method(method) {}
2235 void operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9,A10 a10)
const {(obj->*method)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10);}
2236 void rebind(C& newObj) {obj=&newObj;}
2239 template <
class C,
class D,
class R,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2240 class bound_method<C, R (D::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) const>
2242 typedef R (D::*M)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)
const;
2246 static const int arity=10;
2248 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
2249 bound_method(C& obj, M method): obj(obj), method(method) {}
2250 R operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9,A10 a10)
const {
return (obj.*method)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10);}
2253 template <
class C,
class D,
class A1,
class A2,
class A3,
class A4,
class A5,
class A6,
class A7,
class A8,
class A9,
class A10>
2254 class bound_method<C, void (D::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) const>
2256 typedef void (D::*M)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)
const;
2260 static const int arity=10;
2262 template <
int i>
struct Arg:
public functional::Arg<M,i> {};
2263 bound_method(C& obj, M method): obj(obj), method(method) {}
2264 void operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9,A10 a10)
const {(obj.*method)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10);}
2267 template <
class F,
class Args>
2268 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 10> >,
2269 typename Return<F>::T>::T
2270 apply_nonvoid_fn(F f, Args& a, Fdummy<F> dum=0)
2272 return f(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9]);
2281 template <
class F,
class Args>
2282 typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 10> >,
2284 apply_void_fn(F f, Args& a, Fdummy<F> dum=0)
2286 f(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9]);