Attempt to represent the S^2->S^3 header reorganisation as a series of "hg rename" operations
1 // Boost Lambda Library -- member_ptr.hpp ---------------------
3 // Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
4 // Copyright (C) 2000 Gary Powell (gary.powell@sierra.com)
6 // Distributed under the Boost Software License, Version 1.0. (See
7 // accompanying file LICENSE_1_0.txt or copy at
8 // http://www.boost.org/LICENSE_1_0.txt)
10 // For more information, see www.boost.org
12 // --------------------------------------------------------------------------
14 #if !defined(BOOST_LAMBDA_MEMBER_PTR_HPP)
15 #define BOOST_LAMBDA_MEMBER_PTR_HPP
21 class member_pointer_action {};
26 // the boost type_traits member_pointer traits are not enough,
27 // need to know more details.
29 struct member_pointer {
30 typedef typename boost::add_reference<T>::type type;
31 typedef detail::unspecified class_type;
32 typedef detail::unspecified qualified_class_type;
33 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
34 BOOST_STATIC_CONSTANT(bool, is_function_member = false);
37 template<class T, class U>
38 struct member_pointer<T U::*> {
39 typedef typename boost::add_reference<T>::type type;
41 typedef U qualified_class_type;
42 BOOST_STATIC_CONSTANT(bool, is_data_member = true);
43 BOOST_STATIC_CONSTANT(bool, is_function_member = false);
46 template<class T, class U>
47 struct member_pointer<const T U::*> {
48 typedef typename boost::add_reference<const T>::type type;
50 typedef const U qualified_class_type;
51 BOOST_STATIC_CONSTANT(bool, is_data_member = true);
52 BOOST_STATIC_CONSTANT(bool, is_function_member = false);
55 template<class T, class U>
56 struct member_pointer<volatile T U::*> {
57 typedef typename boost::add_reference<volatile T>::type type;
59 typedef volatile U qualified_class_type;
60 BOOST_STATIC_CONSTANT(bool, is_data_member = true);
61 BOOST_STATIC_CONSTANT(bool, is_function_member = false);
64 template<class T, class U>
65 struct member_pointer<const volatile T U::*> {
66 typedef typename boost::add_reference<const volatile T>::type type;
68 typedef const volatile U qualified_class_type;
69 BOOST_STATIC_CONSTANT(bool, is_data_member = true);
70 BOOST_STATIC_CONSTANT(bool, is_function_member = false);
73 // -- nonconst member functions --
74 template<class T, class U>
75 struct member_pointer<T (U::*)()> {
78 typedef U qualified_class_type;
79 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
80 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
82 template<class T, class U, class A1>
83 struct member_pointer<T (U::*)(A1)> {
86 typedef U qualified_class_type;
87 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
88 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
90 template<class T, class U, class A1, class A2>
91 struct member_pointer<T (U::*)(A1, A2)> {
94 typedef U qualified_class_type;
95 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
96 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
98 template<class T, class U, class A1, class A2, class A3>
99 struct member_pointer<T (U::*)(A1, A2, A3)> {
101 typedef U class_type;
102 typedef U qualified_class_type;
103 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
104 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
106 template<class T, class U, class A1, class A2, class A3, class A4>
107 struct member_pointer<T (U::*)(A1, A2, A3, A4)> {
109 typedef U class_type;
110 typedef U qualified_class_type;
111 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
112 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
114 template<class T, class U, class A1, class A2, class A3, class A4, class A5>
115 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5)> {
117 typedef U class_type;
118 typedef U qualified_class_type;
119 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
120 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
122 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
124 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6)> {
126 typedef U class_type;
127 typedef U qualified_class_type;
128 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
129 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
131 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
133 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7)> {
135 typedef U class_type;
136 typedef U qualified_class_type;
137 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
138 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
140 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
141 class A6, class A7, class A8>
142 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8)> {
144 typedef U class_type;
145 typedef U qualified_class_type;
146 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
147 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
149 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
150 class A6, class A7, class A8, class A9>
151 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
153 typedef U class_type;
154 typedef U qualified_class_type;
155 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
156 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
158 // -- const member functions --
159 template<class T, class U>
160 struct member_pointer<T (U::*)() const> {
162 typedef U class_type;
163 typedef const U qualified_class_type;
164 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
165 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
167 template<class T, class U, class A1>
168 struct member_pointer<T (U::*)(A1) const> {
170 typedef U class_type;
171 typedef const U qualified_class_type;
172 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
173 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
175 template<class T, class U, class A1, class A2>
176 struct member_pointer<T (U::*)(A1, A2) const> {
178 typedef U class_type;
179 typedef const U qualified_class_type;
180 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
181 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
183 template<class T, class U, class A1, class A2, class A3>
184 struct member_pointer<T (U::*)(A1, A2, A3) const> {
186 typedef U class_type;
187 typedef const U qualified_class_type;
188 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
189 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
191 template<class T, class U, class A1, class A2, class A3, class A4>
192 struct member_pointer<T (U::*)(A1, A2, A3, A4) const> {
194 typedef U class_type;
195 typedef const U qualified_class_type;
196 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
197 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
199 template<class T, class U, class A1, class A2, class A3, class A4, class A5>
200 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5) const> {
202 typedef U class_type;
203 typedef const U qualified_class_type;
204 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
205 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
207 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
209 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6) const> {
211 typedef U class_type;
212 typedef const U qualified_class_type;
213 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
214 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
216 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
218 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7) const> {
220 typedef U class_type;
221 typedef const U qualified_class_type;
222 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
223 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
225 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
226 class A6, class A7, class A8>
227 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8) const> {
229 typedef U class_type;
230 typedef const U qualified_class_type;
231 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
232 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
234 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
235 class A6, class A7, class A8, class A9>
236 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const> {
238 typedef U class_type;
239 typedef const U qualified_class_type;
240 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
241 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
244 template<class T, class U>
245 struct member_pointer<T (U::*)() volatile> {
247 typedef U class_type;
248 typedef volatile U qualified_class_type;
249 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
250 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
252 template<class T, class U, class A1>
253 struct member_pointer<T (U::*)(A1) volatile> {
255 typedef U class_type;
256 typedef volatile U qualified_class_type;
257 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
258 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
260 template<class T, class U, class A1, class A2>
261 struct member_pointer<T (U::*)(A1, A2) volatile> {
263 typedef U class_type;
264 typedef volatile U qualified_class_type;
265 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
266 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
268 template<class T, class U, class A1, class A2, class A3>
269 struct member_pointer<T (U::*)(A1, A2, A3) volatile> {
271 typedef U class_type;
272 typedef volatile U qualified_class_type;
273 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
274 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
276 template<class T, class U, class A1, class A2, class A3, class A4>
277 struct member_pointer<T (U::*)(A1, A2, A3, A4) volatile> {
279 typedef U class_type;
280 typedef volatile U qualified_class_type;
281 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
282 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
284 template<class T, class U, class A1, class A2, class A3, class A4, class A5>
285 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5) volatile> {
287 typedef U class_type;
288 typedef volatile U qualified_class_type;
289 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
290 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
292 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
294 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6) volatile> {
296 typedef U class_type;
297 typedef volatile U qualified_class_type;
298 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
299 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
301 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
303 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7) volatile> {
305 typedef U class_type;
306 typedef volatile U qualified_class_type;
307 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
308 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
310 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
311 class A6, class A7, class A8>
312 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8) volatile> {
314 typedef U class_type;
315 typedef volatile U qualified_class_type;
316 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
317 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
319 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
320 class A6, class A7, class A8, class A9>
321 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) volatile> {
323 typedef U class_type;
324 typedef volatile U qualified_class_type;
325 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
326 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
329 template<class T, class U>
330 struct member_pointer<T (U::*)() const volatile> {
332 typedef U class_type;
333 typedef const volatile U qualified_class_type;
334 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
335 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
337 template<class T, class U, class A1>
338 struct member_pointer<T (U::*)(A1) const volatile> {
340 typedef U class_type;
341 typedef const volatile U qualified_class_type;
342 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
343 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
345 template<class T, class U, class A1, class A2>
346 struct member_pointer<T (U::*)(A1, A2) const volatile> {
348 typedef U class_type;
349 typedef const volatile U qualified_class_type;
350 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
351 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
353 template<class T, class U, class A1, class A2, class A3>
354 struct member_pointer<T (U::*)(A1, A2, A3) const volatile> {
356 typedef U class_type;
357 typedef const volatile U qualified_class_type;
358 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
359 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
361 template<class T, class U, class A1, class A2, class A3, class A4>
362 struct member_pointer<T (U::*)(A1, A2, A3, A4) const volatile> {
364 typedef U class_type;
365 typedef const volatile U qualified_class_type;
367 template<class T, class U, class A1, class A2, class A3, class A4, class A5>
368 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5) const volatile> {
370 typedef U class_type;
371 typedef const volatile U qualified_class_type;
372 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
373 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
375 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
377 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6) const volatile> {
379 typedef U class_type;
380 typedef const volatile U qualified_class_type;
381 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
382 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
384 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
386 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7) const volatile> {
388 typedef U class_type;
389 typedef const volatile U qualified_class_type;
390 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
391 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
393 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
394 class A6, class A7, class A8>
395 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8) const volatile> {
397 typedef U class_type;
398 typedef const volatile U qualified_class_type;
399 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
400 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
402 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
403 class A6, class A7, class A8, class A9>
404 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const volatile> {
406 typedef U class_type;
407 typedef const volatile U qualified_class_type;
408 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
409 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
416 // this class holds a pointer to a member function and the object.
417 // when called, it just calls the member function with the parameters
420 // It would have been possible to use existing lambda_functors to represent
421 // a bound member function like this, but to have a separate template is
422 // safer, since now this functor doesn't mix and match with lambda_functors
423 // only thing you can do with this is to call it
425 // note that previously instantiated classes
426 // (other_action<member_pointer_action> and member_pointer_action_helper
427 // guarantee, that A and B are
428 // such types, that for objects a and b of corresponding types, a->*b leads
429 // to the builtin ->* to be called. So types that would end in a call to
430 // a user defined ->* do not create a member_pointer_caller object.
432 template<class RET, class A, class B>
433 class member_pointer_caller {
437 member_pointer_caller(const A& aa, const B& bb) : a(aa), b(bb) {}
439 RET operator()() const { return (a->*b)(); }
442 RET operator()(const A1& a1) const { return (a->*b)(a1); }
444 template<class A1, class A2>
445 RET operator()(const A1& a1, const A2& a2) const { return (a->*b)(a1, a2); }
447 template<class A1, class A2, class A3>
448 RET operator()(const A1& a1, const A2& a2, const A3& a3) const {
449 return (a->*b)(a1, a2, a3);
452 template<class A1, class A2, class A3, class A4>
453 RET operator()(const A1& a1, const A2& a2, const A3& a3,
454 const A4& a4) const {
455 return (a->*b)(a1, a2, a3, a4);
458 template<class A1, class A2, class A3, class A4, class A5>
459 RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
460 const A5& a5) const {
461 return (a->*b)(a1, a2, a3, a4, a5);
464 template<class A1, class A2, class A3, class A4, class A5, class A6>
465 RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
466 const A5& a5, const A6& a6) const {
467 return (a->*b)(a1, a2, a3, a4, a5, a6);
470 template<class A1, class A2, class A3, class A4, class A5, class A6,
472 RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
473 const A5& a5, const A6& a6, const A7& a7) const {
474 return (a->*b)(a1, a2, a3, a4, a5, a6, a7);
477 template<class A1, class A2, class A3, class A4, class A5, class A6,
479 RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
480 const A5& a5, const A6& a6, const A7& a7,
481 const A8& a8) const {
482 return (a->*b)(a1, a2, a3, a4, a5, a6, a7, a8);
485 template<class A1, class A2, class A3, class A4, class A5, class A6,
486 class A7, class A8, class A9>
487 RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
488 const A5& a5, const A6& a6, const A7& a7,
489 const A8& a8, const A9& a9) const {
490 return (a->*b)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
495 // helper templates for return type deduction and action classes
496 // different cases for data member, function member, neither
499 template <bool Is_data_member, bool Is_function_member>
500 struct member_pointer_action_helper;
501 // cannot be both, no body provided
504 // this means, that B is a data member and A is a pointer type,
505 // so either built-in ->* should be called, or there is an error
507 struct member_pointer_action_helper<true, false> {
510 template<class RET, class A, class B>
511 static RET apply(A& a, B& b) {
515 template<class A, class B>
518 typedef typename detail::remove_reference_and_cv<B>::type plainB;
520 typedef typename detail::member_pointer<plainB>::type type0;
521 // we remove the reference now, as we may have to add cv:s
522 typedef typename boost::remove_reference<type0>::type type1;
524 // A is a reference to pointer
525 // remove the top level cv qualifiers and reference
527 detail::remove_reference_and_cv<A>::type non_ref_A;
529 // A is a pointer type, so take the type pointed to
530 typedef typename ::boost::remove_pointer<non_ref_A>::type non_pointer_A;
533 // For non-reference types, we must add const and/or volatile if
534 // the pointer type has these qualifiers
535 // If the member is a reference, these do not have any effect
536 // (cv T == T if T is a reference type)
537 typedef typename detail::IF<
538 ::boost::is_const<non_pointer_A>::value,
539 typename ::boost::add_const<type1>::type,
542 typedef typename detail::IF<
543 ::boost::is_volatile<non_pointer_A>::value,
544 typename ::boost::add_volatile<type2>::type,
547 // add reference back
548 typedef typename ::boost::add_reference<type3>::type type;
554 struct member_pointer_action_helper<false, false> {
556 template<class RET, class A, class B>
557 static RET apply(A& a, B& b) {
558 // not a built in member pointer operator, just call ->*
561 // an overloaded member pointer operators, user should have specified
563 // At this point we know that there is no matching specialization for
564 // return_type_2, so try return_type_2_plain
565 template<class A, class B>
568 typedef typename plain_return_type_2<
569 other_action<member_pointer_action>, A, B
576 // member pointer function case
577 // This is a built in ->* call for a member function,
578 // the only thing that you can do with that, is to give it some arguments
579 // note, it is guaranteed that A is a pointer type, and thus it cannot
580 // be a call to overloaded ->*
582 struct member_pointer_action_helper<false, true> {
585 template<class RET, class A, class B>
586 static RET apply(A& a, B& b) {
587 typedef typename ::boost::remove_cv<B>::type plainB;
588 typedef typename detail::member_pointer<plainB>::type ret_t;
589 typedef typename ::boost::remove_cv<A>::type plainA;
591 // we always strip cv:s to
592 // make the two routes (calling and type deduction)
593 // to give the same results (and the const does not make any functional
595 return detail::member_pointer_caller<ret_t, plainA, plainB>(a, b);
598 template<class A, class B>
600 typedef typename detail::remove_reference_and_cv<B>::type plainB;
601 typedef typename detail::member_pointer<plainB>::type ret_t;
602 typedef typename detail::remove_reference_and_cv<A>::type plainA;
604 typedef detail::member_pointer_caller<ret_t, plainA, plainB> type;
610 template<> class other_action<member_pointer_action> {
612 template<class RET, class A, class B>
613 static RET apply(A& a, B& b) {
615 ::boost::remove_cv<B>::type plainB;
617 return detail::member_pointer_action_helper<
618 boost::is_pointer<A>::value &&
619 detail::member_pointer<plainB>::is_data_member,
620 boost::is_pointer<A>::value &&
621 detail::member_pointer<plainB>::is_function_member
622 >::template apply<RET>(a, b);
626 // return type deduction --
628 // If the right argument is a pointer to data member,
629 // and the left argument is of compatible pointer to class type
630 // return type is a reference to the data member type
632 // if right argument is a pointer to a member function, and the left
633 // argument is of a compatible type, the return type is a
634 // member_pointer_caller (see above)
636 // Otherwise, return type deduction fails. There is either an error,
637 // or the user is trying to call an overloaded ->*
638 // In such a case either ret<> must be used, or a return_type_2 user
639 // defined specialization must be provided
642 template<class A, class B>
643 struct return_type_2<other_action<member_pointer_action>, A, B> {
646 detail::remove_reference_and_cv<B>::type plainB;
649 detail::member_pointer_action_helper<
650 detail::member_pointer<plainB>::is_data_member,
651 detail::member_pointer<plainB>::is_function_member
652 >::template return_type<A, B>::type type;
655 // this is the way the generic lambda_functor_base functions instantiate
656 // return type deduction. We turn it into return_type_2, so that the
657 // user can provide specializations on that level.
659 struct return_type_N<other_action<member_pointer_action>, Args> {
660 typedef typename boost::tuples::element<0, Args>::type A;
661 typedef typename boost::tuples::element<1, Args>::type B;
663 return_type_2<other_action<member_pointer_action>,
664 typename boost::remove_reference<A>::type,
665 typename boost::remove_reference<B>::type
670 template<class Arg1, class Arg2>
674 action<2, other_action<member_pointer_action> >,
675 tuple<lambda_functor<Arg1>, typename const_copy_argument<Arg2>::type>
678 operator->*(const lambda_functor<Arg1>& a1, const Arg2& a2)
682 action<2, other_action<member_pointer_action> >,
683 tuple<lambda_functor<Arg1>, typename const_copy_argument<Arg2>::type>
685 (tuple<lambda_functor<Arg1>,
686 typename const_copy_argument<Arg2>::type>(a1, a2));
689 template<class Arg1, class Arg2>
693 action<2, other_action<member_pointer_action> >,
694 tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
697 operator->*(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2)
701 action<2, other_action<member_pointer_action> >,
702 tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
704 (tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >(a1, a2));
707 template<class Arg1, class Arg2>
711 action<2, other_action<member_pointer_action> >,
712 tuple<typename const_copy_argument<Arg1>::type, lambda_functor<Arg2> >
715 operator->*(const Arg1& a1, const lambda_functor<Arg2>& a2)
719 action<2, other_action<member_pointer_action> >,
720 tuple<typename const_copy_argument<Arg1>::type, lambda_functor<Arg2> >
722 (tuple<typename const_copy_argument<Arg1>::type,
723 lambda_functor<Arg2> >(a1, a2));
727 } // namespace lambda