Line data Source code
1 : //
2 : // bind/mem_fn_template.hpp
3 : //
4 : // Do not include this header directly
5 : //
6 : // Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
7 : //
8 : // Distributed under the Boost Software License, Version 1.0. (See
9 : // accompanying file LICENSE_1_0.txt or copy at
10 : // http://www.boost.org/LICENSE_1_0.txt)
11 : //
12 : // See http://www.boost.org/libs/bind/mem_fn.html for documentation.
13 : //
14 :
15 : #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
16 : # define BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
17 : #endif
18 :
19 : // mf0
20 :
21 : template<class R, class T BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf0)
22 : {
23 : public:
24 :
25 : typedef R result_type;
26 : typedef T * argument_type;
27 :
28 : private:
29 :
30 : BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) ())
31 : F f_;
32 :
33 : template<class U> R call(U & u, T const *) const
34 : {
35 : BOOST_MEM_FN_RETURN (u.*f_)();
36 : }
37 :
38 : template<class U> R call(U & u, void const *) const
39 : {
40 : BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
41 : }
42 :
43 : public:
44 :
45 0 : explicit BOOST_MEM_FN_NAME(mf0)(F f): f_(f) {}
46 :
47 : R operator()(T * p) const
48 : {
49 : BOOST_MEM_FN_RETURN (p->*f_)();
50 : }
51 :
52 : template<class U> R operator()(U & u) const
53 : {
54 : U const * p = 0;
55 : BOOST_MEM_FN_RETURN call(u, p);
56 : }
57 :
58 : #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
59 :
60 : template<class U> R operator()(U const & u) const
61 : {
62 : U const * p = 0;
63 : BOOST_MEM_FN_RETURN call(u, p);
64 : }
65 :
66 : #endif
67 :
68 0 : R operator()(T & t) const
69 : {
70 0 : BOOST_MEM_FN_RETURN (t.*f_)();
71 : }
72 :
73 : bool operator==(BOOST_MEM_FN_NAME(mf0) const & rhs) const
74 : {
75 : return f_ == rhs.f_;
76 : }
77 :
78 : bool operator!=(BOOST_MEM_FN_NAME(mf0) const & rhs) const
79 : {
80 : return f_ != rhs.f_;
81 : }
82 : };
83 :
84 : // cmf0
85 :
86 : template<class R, class T BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf0)
87 : {
88 : public:
89 :
90 : typedef R result_type;
91 : typedef T const * argument_type;
92 :
93 : private:
94 :
95 : BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) () const)
96 : F f_;
97 :
98 : template<class U> R call(U & u, T const *) const
99 : {
100 : BOOST_MEM_FN_RETURN (u.*f_)();
101 : }
102 :
103 : template<class U> R call(U & u, void const *) const
104 : {
105 : BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
106 : }
107 :
108 : public:
109 :
110 0 : explicit BOOST_MEM_FN_NAME(cmf0)(F f): f_(f) {}
111 :
112 : template<class U> R operator()(U const & u) const
113 : {
114 : U const * p = 0;
115 : BOOST_MEM_FN_RETURN call(u, p);
116 : }
117 :
118 0 : R operator()(T const & t) const
119 : {
120 0 : BOOST_MEM_FN_RETURN (t.*f_)();
121 : }
122 :
123 : bool operator==(BOOST_MEM_FN_NAME(cmf0) const & rhs) const
124 : {
125 : return f_ == rhs.f_;
126 : }
127 :
128 : bool operator!=(BOOST_MEM_FN_NAME(cmf0) const & rhs) const
129 : {
130 : return f_ != rhs.f_;
131 : }
132 : };
133 :
134 : // mf1
135 :
136 : template<class R, class T, class A1 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf1)
137 : {
138 : public:
139 :
140 : typedef R result_type;
141 : typedef T * first_argument_type;
142 : typedef A1 second_argument_type;
143 :
144 : private:
145 :
146 : BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1))
147 : F f_;
148 :
149 : template<class U, class B1> R call(U & u, T const *, B1 & b1) const
150 : {
151 : BOOST_MEM_FN_RETURN (u.*f_)(b1);
152 : }
153 :
154 : template<class U, class B1> R call(U & u, void const *, B1 & b1) const
155 : {
156 : BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
157 : }
158 :
159 : public:
160 :
161 : explicit BOOST_MEM_FN_NAME(mf1)(F f): f_(f) {}
162 :
163 : R operator()(T * p, A1 a1) const
164 : {
165 : BOOST_MEM_FN_RETURN (p->*f_)(a1);
166 : }
167 :
168 : template<class U> R operator()(U & u, A1 a1) const
169 : {
170 : U const * p = 0;
171 : BOOST_MEM_FN_RETURN call(u, p, a1);
172 : }
173 :
174 : #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
175 :
176 : template<class U> R operator()(U const & u, A1 a1) const
177 : {
178 : U const * p = 0;
179 : BOOST_MEM_FN_RETURN call(u, p, a1);
180 : }
181 :
182 : #endif
183 :
184 : R operator()(T & t, A1 a1) const
185 : {
186 : BOOST_MEM_FN_RETURN (t.*f_)(a1);
187 : }
188 :
189 : bool operator==(BOOST_MEM_FN_NAME(mf1) const & rhs) const
190 : {
191 : return f_ == rhs.f_;
192 : }
193 :
194 : bool operator!=(BOOST_MEM_FN_NAME(mf1) const & rhs) const
195 : {
196 : return f_ != rhs.f_;
197 : }
198 : };
199 :
200 : // cmf1
201 :
202 : template<class R, class T, class A1 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf1)
203 : {
204 : public:
205 :
206 : typedef R result_type;
207 : typedef T const * first_argument_type;
208 : typedef A1 second_argument_type;
209 :
210 : private:
211 :
212 : BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1) const)
213 : F f_;
214 :
215 : template<class U, class B1> R call(U & u, T const *, B1 & b1) const
216 : {
217 : BOOST_MEM_FN_RETURN (u.*f_)(b1);
218 : }
219 :
220 : template<class U, class B1> R call(U & u, void const *, B1 & b1) const
221 : {
222 : BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
223 : }
224 :
225 : public:
226 :
227 : explicit BOOST_MEM_FN_NAME(cmf1)(F f): f_(f) {}
228 :
229 : template<class U> R operator()(U const & u, A1 a1) const
230 : {
231 : U const * p = 0;
232 : BOOST_MEM_FN_RETURN call(u, p, a1);
233 : }
234 :
235 : R operator()(T const & t, A1 a1) const
236 : {
237 : BOOST_MEM_FN_RETURN (t.*f_)(a1);
238 : }
239 :
240 : bool operator==(BOOST_MEM_FN_NAME(cmf1) const & rhs) const
241 : {
242 : return f_ == rhs.f_;
243 : }
244 :
245 : bool operator!=(BOOST_MEM_FN_NAME(cmf1) const & rhs) const
246 : {
247 : return f_ != rhs.f_;
248 : }
249 : };
250 :
251 : // mf2
252 :
253 : template<class R, class T, class A1, class A2 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf2)
254 : {
255 : public:
256 :
257 : typedef R result_type;
258 :
259 : private:
260 :
261 : BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2))
262 : F f_;
263 :
264 : template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
265 : {
266 : BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
267 : }
268 :
269 : template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
270 : {
271 : BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
272 : }
273 :
274 : public:
275 :
276 : explicit BOOST_MEM_FN_NAME(mf2)(F f): f_(f) {}
277 :
278 : R operator()(T * p, A1 a1, A2 a2) const
279 : {
280 : BOOST_MEM_FN_RETURN (p->*f_)(a1, a2);
281 : }
282 :
283 : template<class U> R operator()(U & u, A1 a1, A2 a2) const
284 : {
285 : U const * p = 0;
286 : BOOST_MEM_FN_RETURN call(u, p, a1, a2);
287 : }
288 :
289 : #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
290 :
291 : template<class U> R operator()(U const & u, A1 a1, A2 a2) const
292 : {
293 : U const * p = 0;
294 : BOOST_MEM_FN_RETURN call(u, p, a1, a2);
295 : }
296 :
297 : #endif
298 :
299 : R operator()(T & t, A1 a1, A2 a2) const
300 : {
301 : BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
302 : }
303 :
304 : bool operator==(BOOST_MEM_FN_NAME(mf2) const & rhs) const
305 : {
306 : return f_ == rhs.f_;
307 : }
308 :
309 : bool operator!=(BOOST_MEM_FN_NAME(mf2) const & rhs) const
310 : {
311 : return f_ != rhs.f_;
312 : }
313 : };
314 :
315 : // cmf2
316 :
317 : template<class R, class T, class A1, class A2 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf2)
318 : {
319 : public:
320 :
321 : typedef R result_type;
322 :
323 : private:
324 :
325 : BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2) const)
326 : F f_;
327 :
328 : template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
329 : {
330 : BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
331 : }
332 :
333 : template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
334 : {
335 : BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
336 : }
337 :
338 : public:
339 :
340 : explicit BOOST_MEM_FN_NAME(cmf2)(F f): f_(f) {}
341 :
342 : template<class U> R operator()(U const & u, A1 a1, A2 a2) const
343 : {
344 : U const * p = 0;
345 : BOOST_MEM_FN_RETURN call(u, p, a1, a2);
346 : }
347 :
348 : R operator()(T const & t, A1 a1, A2 a2) const
349 : {
350 : BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
351 : }
352 :
353 : bool operator==(BOOST_MEM_FN_NAME(cmf2) const & rhs) const
354 : {
355 : return f_ == rhs.f_;
356 : }
357 :
358 : bool operator!=(BOOST_MEM_FN_NAME(cmf2) const & rhs) const
359 : {
360 : return f_ != rhs.f_;
361 : }
362 : };
363 :
364 : // mf3
365 :
366 : template<class R, class T, class A1, class A2, class A3 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf3)
367 : {
368 : public:
369 :
370 : typedef R result_type;
371 :
372 : private:
373 :
374 : BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3))
375 : F f_;
376 :
377 : template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
378 : {
379 : BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
380 : }
381 :
382 : template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
383 : {
384 : BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
385 : }
386 :
387 : public:
388 :
389 0 : explicit BOOST_MEM_FN_NAME(mf3)(F f): f_(f) {}
390 :
391 0 : R operator()(T * p, A1 a1, A2 a2, A3 a3) const
392 : {
393 0 : BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3);
394 : }
395 :
396 : template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
397 : {
398 : U const * p = 0;
399 : BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
400 : }
401 :
402 : #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
403 :
404 : template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
405 : {
406 : U const * p = 0;
407 : BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
408 : }
409 :
410 : #endif
411 :
412 : R operator()(T & t, A1 a1, A2 a2, A3 a3) const
413 : {
414 : BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
415 : }
416 :
417 : bool operator==(BOOST_MEM_FN_NAME(mf3) const & rhs) const
418 : {
419 : return f_ == rhs.f_;
420 : }
421 :
422 : bool operator!=(BOOST_MEM_FN_NAME(mf3) const & rhs) const
423 : {
424 : return f_ != rhs.f_;
425 : }
426 : };
427 :
428 : // cmf3
429 :
430 : template<class R, class T, class A1, class A2, class A3 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf3)
431 : {
432 : public:
433 :
434 : typedef R result_type;
435 :
436 : private:
437 :
438 : BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const)
439 : F f_;
440 :
441 : template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
442 : {
443 : BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
444 : }
445 :
446 : template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
447 : {
448 : BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
449 : }
450 :
451 : public:
452 :
453 : explicit BOOST_MEM_FN_NAME(cmf3)(F f): f_(f) {}
454 :
455 : template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
456 : {
457 : U const * p = 0;
458 : BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
459 : }
460 :
461 : R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
462 : {
463 : BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
464 : }
465 :
466 : bool operator==(BOOST_MEM_FN_NAME(cmf3) const & rhs) const
467 : {
468 : return f_ == rhs.f_;
469 : }
470 :
471 : bool operator!=(BOOST_MEM_FN_NAME(cmf3) const & rhs) const
472 : {
473 : return f_ != rhs.f_;
474 : }
475 : };
476 :
477 : // mf4
478 :
479 : template<class R, class T, class A1, class A2, class A3, class A4 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf4)
480 : {
481 : public:
482 :
483 : typedef R result_type;
484 :
485 : private:
486 :
487 : BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4))
488 : F f_;
489 :
490 : template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
491 : {
492 : BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
493 : }
494 :
495 : template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
496 : {
497 : BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
498 : }
499 :
500 : public:
501 :
502 0 : explicit BOOST_MEM_FN_NAME(mf4)(F f): f_(f) {}
503 :
504 : R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
505 : {
506 : BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4);
507 : }
508 :
509 : template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
510 : {
511 : U const * p = 0;
512 : BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
513 : }
514 :
515 : #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
516 :
517 : template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
518 : {
519 : U const * p = 0;
520 : BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
521 : }
522 :
523 : #endif
524 :
525 : R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
526 : {
527 : BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
528 : }
529 :
530 : bool operator==(BOOST_MEM_FN_NAME(mf4) const & rhs) const
531 : {
532 : return f_ == rhs.f_;
533 : }
534 :
535 : bool operator!=(BOOST_MEM_FN_NAME(mf4) const & rhs) const
536 : {
537 : return f_ != rhs.f_;
538 : }
539 : };
540 :
541 : // cmf4
542 :
543 : template<class R, class T, class A1, class A2, class A3, class A4 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf4)
544 : {
545 : public:
546 :
547 : typedef R result_type;
548 :
549 : private:
550 :
551 : BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const)
552 : F f_;
553 :
554 : template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
555 : {
556 : BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
557 : }
558 :
559 : template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
560 : {
561 : BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
562 : }
563 :
564 : public:
565 :
566 : explicit BOOST_MEM_FN_NAME(cmf4)(F f): f_(f) {}
567 :
568 : template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
569 : {
570 : U const * p = 0;
571 : BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
572 : }
573 :
574 : R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
575 : {
576 : BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
577 : }
578 :
579 : bool operator==(BOOST_MEM_FN_NAME(cmf4) const & rhs) const
580 : {
581 : return f_ == rhs.f_;
582 : }
583 :
584 : bool operator!=(BOOST_MEM_FN_NAME(cmf4) const & rhs) const
585 : {
586 : return f_ != rhs.f_;
587 : }
588 : };
589 :
590 : // mf5
591 :
592 : template<class R, class T, class A1, class A2, class A3, class A4, class A5 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf5)
593 : {
594 : public:
595 :
596 : typedef R result_type;
597 :
598 : private:
599 :
600 : BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5))
601 : F f_;
602 :
603 : template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
604 : {
605 : BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5);
606 : }
607 :
608 : template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
609 : {
610 : BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
611 : }
612 :
613 : public:
614 :
615 : explicit BOOST_MEM_FN_NAME(mf5)(F f): f_(f) {}
616 :
617 : R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
618 : {
619 : BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5);
620 : }
621 :
622 : template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
623 : {
624 : U const * p = 0;
625 : BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
626 : }
627 :
628 : #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
629 :
630 : template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
631 : {
632 : U const * p = 0;
633 : BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
634 : }
635 :
636 : #endif
637 :
638 : R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
639 : {
640 : BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
641 : }
642 :
643 : bool operator==(BOOST_MEM_FN_NAME(mf5) const & rhs) const
644 : {
645 : return f_ == rhs.f_;
646 : }
647 :
648 : bool operator!=(BOOST_MEM_FN_NAME(mf5) const & rhs) const
649 : {
650 : return f_ != rhs.f_;
651 : }
652 : };
653 :
654 : // cmf5
655 :
656 : template<class R, class T, class A1, class A2, class A3, class A4, class A5 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf5)
657 : {
658 : public:
659 :
660 : typedef R result_type;
661 :
662 : private:
663 :
664 : BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const)
665 : F f_;
666 :
667 : template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
668 : {
669 : BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5);
670 : }
671 :
672 : template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
673 : {
674 : BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
675 : }
676 :
677 : public:
678 :
679 : explicit BOOST_MEM_FN_NAME(cmf5)(F f): f_(f) {}
680 :
681 : template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
682 : {
683 : U const * p = 0;
684 : BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
685 : }
686 :
687 : R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
688 : {
689 : BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
690 : }
691 :
692 : bool operator==(BOOST_MEM_FN_NAME(cmf5) const & rhs) const
693 : {
694 : return f_ == rhs.f_;
695 : }
696 :
697 : bool operator!=(BOOST_MEM_FN_NAME(cmf5) const & rhs) const
698 : {
699 : return f_ != rhs.f_;
700 : }
701 : };
702 :
703 : // mf6
704 :
705 : template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf6)
706 : {
707 : public:
708 :
709 : typedef R result_type;
710 :
711 : private:
712 :
713 : BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6))
714 : F f_;
715 :
716 : template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
717 : {
718 : BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6);
719 : }
720 :
721 : template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
722 : {
723 : BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
724 : }
725 :
726 : public:
727 :
728 : explicit BOOST_MEM_FN_NAME(mf6)(F f): f_(f) {}
729 :
730 : R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
731 : {
732 : BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6);
733 : }
734 :
735 : template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
736 : {
737 : U const * p = 0;
738 : BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
739 : }
740 :
741 : #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
742 :
743 : template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
744 : {
745 : U const * p = 0;
746 : BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
747 : }
748 :
749 : #endif
750 :
751 : R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
752 : {
753 : BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
754 : }
755 :
756 : bool operator==(BOOST_MEM_FN_NAME(mf6) const & rhs) const
757 : {
758 : return f_ == rhs.f_;
759 : }
760 :
761 : bool operator!=(BOOST_MEM_FN_NAME(mf6) const & rhs) const
762 : {
763 : return f_ != rhs.f_;
764 : }
765 : };
766 :
767 : // cmf6
768 :
769 : template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf6)
770 : {
771 : public:
772 :
773 : typedef R result_type;
774 :
775 : private:
776 :
777 : BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const)
778 : F f_;
779 :
780 : template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
781 : {
782 : BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6);
783 : }
784 :
785 : template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
786 : {
787 : BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
788 : }
789 :
790 : public:
791 :
792 : explicit BOOST_MEM_FN_NAME(cmf6)(F f): f_(f) {}
793 :
794 : template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
795 : {
796 : U const * p = 0;
797 : BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
798 : }
799 :
800 : R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
801 : {
802 : BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
803 : }
804 :
805 : bool operator==(BOOST_MEM_FN_NAME(cmf6) const & rhs) const
806 : {
807 : return f_ == rhs.f_;
808 : }
809 :
810 : bool operator!=(BOOST_MEM_FN_NAME(cmf6) const & rhs) const
811 : {
812 : return f_ != rhs.f_;
813 : }
814 : };
815 :
816 : // mf7
817 :
818 : template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf7)
819 : {
820 : public:
821 :
822 : typedef R result_type;
823 :
824 : private:
825 :
826 : BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7))
827 : F f_;
828 :
829 : template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
830 : {
831 : BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
832 : }
833 :
834 : template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
835 : {
836 : BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
837 : }
838 :
839 : public:
840 :
841 : explicit BOOST_MEM_FN_NAME(mf7)(F f): f_(f) {}
842 :
843 : R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
844 : {
845 : BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
846 : }
847 :
848 : template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
849 : {
850 : U const * p = 0;
851 : BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
852 : }
853 :
854 : #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
855 :
856 : template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
857 : {
858 : U const * p = 0;
859 : BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
860 : }
861 :
862 : #endif
863 :
864 : R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
865 : {
866 : BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
867 : }
868 :
869 : bool operator==(BOOST_MEM_FN_NAME(mf7) const & rhs) const
870 : {
871 : return f_ == rhs.f_;
872 : }
873 :
874 : bool operator!=(BOOST_MEM_FN_NAME(mf7) const & rhs) const
875 : {
876 : return f_ != rhs.f_;
877 : }
878 : };
879 :
880 : // cmf7
881 :
882 : template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf7)
883 : {
884 : public:
885 :
886 : typedef R result_type;
887 :
888 : private:
889 :
890 : BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const)
891 : F f_;
892 :
893 : template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
894 : {
895 : BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
896 : }
897 :
898 : template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
899 : {
900 : BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
901 : }
902 :
903 : public:
904 :
905 : explicit BOOST_MEM_FN_NAME(cmf7)(F f): f_(f) {}
906 :
907 : template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
908 : {
909 : U const * p = 0;
910 : BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
911 : }
912 :
913 : R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
914 : {
915 : BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
916 : }
917 :
918 : bool operator==(BOOST_MEM_FN_NAME(cmf7) const & rhs) const
919 : {
920 : return f_ == rhs.f_;
921 : }
922 :
923 : bool operator!=(BOOST_MEM_FN_NAME(cmf7) const & rhs) const
924 : {
925 : return f_ != rhs.f_;
926 : }
927 : };
928 :
929 : // mf8
930 :
931 : template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf8)
932 : {
933 : public:
934 :
935 : typedef R result_type;
936 :
937 : private:
938 :
939 : BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8))
940 : F f_;
941 :
942 : template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
943 : {
944 : BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
945 : }
946 :
947 : template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
948 : {
949 : BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
950 : }
951 :
952 : public:
953 :
954 : explicit BOOST_MEM_FN_NAME(mf8)(F f): f_(f) {}
955 :
956 : R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
957 : {
958 : BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
959 : }
960 :
961 : template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
962 : {
963 : U const * p = 0;
964 : BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
965 : }
966 :
967 : #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
968 :
969 : template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
970 : {
971 : U const * p = 0;
972 : BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
973 : }
974 :
975 : #endif
976 :
977 : R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
978 : {
979 : BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
980 : }
981 :
982 : bool operator==(BOOST_MEM_FN_NAME(mf8) const & rhs) const
983 : {
984 : return f_ == rhs.f_;
985 : }
986 :
987 : bool operator!=(BOOST_MEM_FN_NAME(mf8) const & rhs) const
988 : {
989 : return f_ != rhs.f_;
990 : }
991 : };
992 :
993 : // cmf8
994 :
995 : template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf8)
996 : {
997 : public:
998 :
999 : typedef R result_type;
1000 :
1001 : private:
1002 :
1003 : BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const)
1004 : F f_;
1005 :
1006 : template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
1007 : {
1008 : BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
1009 : }
1010 :
1011 : template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
1012 : {
1013 : BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
1014 : }
1015 :
1016 : public:
1017 :
1018 : explicit BOOST_MEM_FN_NAME(cmf8)(F f): f_(f) {}
1019 :
1020 : R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
1021 : {
1022 : BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
1023 : }
1024 :
1025 : template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
1026 : {
1027 : U const * p = 0;
1028 : BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
1029 : }
1030 :
1031 : R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
1032 : {
1033 : BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
1034 : }
1035 :
1036 : bool operator==(BOOST_MEM_FN_NAME(cmf8) const & rhs) const
1037 : {
1038 : return f_ == rhs.f_;
1039 : }
1040 :
1041 : bool operator!=(BOOST_MEM_FN_NAME(cmf8) const & rhs) const
1042 : {
1043 : return f_ != rhs.f_;
1044 : }
1045 : };
1046 :
1047 : #undef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
|
