1 // Boost Lambda Library -- member_ptr.hpp ---------------------
2
3 // Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
4 // Copyright (C) 2000 Gary Powell (gary.powell@sierra.com)
5 //
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)
9 //
10 // For more information, see www.boost.org
11
12 // --------------------------------------------------------------------------
13
14 #if !defined(BOOST_LAMBDA_MEMBER_PTR_HPP)
15 #define BOOST_LAMBDA_MEMBER_PTR_HPP
16
17 namespace boost {
18 namespace lambda {
19
20
21 class member_pointer_action {};
22
23
24 namespace detail {
25
26 // the boost type_traits member_pointer traits are not enough,
27 // need to know more details.
28 template<class T>
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);
35 };
36
37 template<class T, class U>
38 struct member_pointer<T U::*> {
39 typedef typename boost::add_reference<T>::type type;
40 typedef U class_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);
44 };
45
46 template<class T, class U>
47 struct member_pointer<const T U::*> {
48 typedef typename boost::add_reference<const T>::type type;
49 typedef U class_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);
53 };
54
55 template<class T, class U>
56 struct member_pointer<volatile T U::*> {
57 typedef typename boost::add_reference<volatile T>::type type;
58 typedef U class_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);
62 };
63
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;
67 typedef U class_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);
71 };
72
73 // -- nonconst member functions --
74 template<class T, class U>
75 struct member_pointer<T (U::*)()> {
76 typedef T type;
77 typedef U class_type;
78 typedef U qualified_class_type;
79 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
80 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
81 };
82 template<class T, class U, class A1>
83 struct member_pointer<T (U::*)(A1)> {
84 typedef T type;
85 typedef U class_type;
86 typedef U qualified_class_type;
87 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
88 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
89 };
90 template<class T, class U, class A1, class A2>
91 struct member_pointer<T (U::*)(A1, A2)> {
92 typedef T type;
93 typedef U class_type;
94 typedef U qualified_class_type;
95 BOOST_STATIC_CONSTANT(bool, is_data_member = false);
96 BOOST_STATIC_CONSTANT(bool, is_function_member = true);
97 };
98 template<class T, class U, class A1, class A2, class A3>
99 struct member_pointer<T (U::*)(A1, A2, A3)> {
100 typedef T type;
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);
105 };
106 template<class T, class U, class A1, class A2, class A3, class A4>
107 struct member_pointer<T (U::*)(A1, A2, A3, A4)> {
108 typedef T type;
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);
113 };
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)> {
116 typedef T type;
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);
121 };
122 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
123 class A6>
124 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6)> {
125 typedef T type;
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);
130 };
131 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
132 class A6, class A7>
133 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7)> {
134 typedef T type;
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);
139 };
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)> {
143 typedef T type;
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);
148 };
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)> {
152 typedef T type;
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);
157 };
158 // -- const member functions --
159 template<class T, class U>
160 struct member_pointer<T (U::*)() const> {
161 typedef T type;
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);
166 };
167 template<class T, class U, class A1>
168 struct member_pointer<T (U::*)(A1) const> {
169 typedef T type;
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);
174 };
175 template<class T, class U, class A1, class A2>
176 struct member_pointer<T (U::*)(A1, A2) const> {
177 typedef T type;
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);
182 };
183 template<class T, class U, class A1, class A2, class A3>
184 struct member_pointer<T (U::*)(A1, A2, A3) const> {
185 typedef T type;
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);
190 };
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> {
193 typedef T type;
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);
198 };
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> {
201 typedef T type;
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);
206 };
207 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
208 class A6>
209 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6) const> {
210 typedef T type;
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);
215 };
216 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
217 class A6, class A7>
218 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7) const> {
219 typedef T type;
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);
224 };
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> {
228 typedef T type;
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);
233 };
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> {
237 typedef T type;
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);
242 };
243 // -- volatile --
244 template<class T, class U>
245 struct member_pointer<T (U::*)() volatile> {
246 typedef T type;
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);
251 };
252 template<class T, class U, class A1>
253 struct member_pointer<T (U::*)(A1) volatile> {
254 typedef T type;
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);
259 };
260 template<class T, class U, class A1, class A2>
261 struct member_pointer<T (U::*)(A1, A2) volatile> {
262 typedef T type;
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);
267 };
268 template<class T, class U, class A1, class A2, class A3>
269 struct member_pointer<T (U::*)(A1, A2, A3) volatile> {
270 typedef T type;
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);
275 };
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> {
278 typedef T type;
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);
283 };
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> {
286 typedef T type;
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);
291 };
292 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
293 class A6>
294 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6) volatile> {
295 typedef T type;
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);
300 };
301 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
302 class A6, class A7>
303 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7) volatile> {
304 typedef T type;
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);
309 };
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> {
313 typedef T type;
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);
318 };
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> {
322 typedef T type;
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);
327 };
328 // -- const volatile
329 template<class T, class U>
330 struct member_pointer<T (U::*)() const volatile> {
331 typedef T type;
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);
336 };
337 template<class T, class U, class A1>
338 struct member_pointer<T (U::*)(A1) const volatile> {
339 typedef T type;
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);
344 };
345 template<class T, class U, class A1, class A2>
346 struct member_pointer<T (U::*)(A1, A2) const volatile> {
347 typedef T type;
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);
352 };
353 template<class T, class U, class A1, class A2, class A3>
354 struct member_pointer<T (U::*)(A1, A2, A3) const volatile> {
355 typedef T type;
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);
360 };
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> {
363 typedef T type;
364 typedef U class_type;
365 typedef const volatile U qualified_class_type;
366 };
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> {
369 typedef T type;
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);
374 };
375 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
376 class A6>
377 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6) const volatile> {
378 typedef T type;
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);
383 };
384 template<class T, class U, class A1, class A2, class A3, class A4, class A5,
385 class A6, class A7>
386 struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7) const volatile> {
387 typedef T type;
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);
392 };
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> {
396 typedef T type;
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);
401 };
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> {
405 typedef T type;
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);
410 };
411
412 } // detail
413
414 namespace detail {
415
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
418 // provided
419
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
424
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.
431
432 template<class RET, class A, class B>
433 class member_pointer_caller {
434 A a; B b;
435
436 public:
member_pointer_caller(const A & aa,const B & bb)437 member_pointer_caller(const A& aa, const B& bb) : a(aa), b(bb) {}
438
operator ()() const439 RET operator()() const { return (a->*b)(); }
440
441 template<class A1>
operator ()(const A1 & a1) const442 RET operator()(const A1& a1) const { return (a->*b)(a1); }
443
444 template<class A1, class A2>
operator ()(const A1 & a1,const A2 & a2) const445 RET operator()(const A1& a1, const A2& a2) const { return (a->*b)(a1, a2); }
446
447 template<class A1, class A2, class A3>
operator ()(const A1 & a1,const A2 & a2,const A3 & a3) const448 RET operator()(const A1& a1, const A2& a2, const A3& a3) const {
449 return (a->*b)(a1, a2, a3);
450 }
451
452 template<class A1, class A2, class A3, class A4>
operator ()(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4) const453 RET operator()(const A1& a1, const A2& a2, const A3& a3,
454 const A4& a4) const {
455 return (a->*b)(a1, a2, a3, a4);
456 }
457
458 template<class A1, class A2, class A3, class A4, class A5>
operator ()(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5) const459 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);
462 }
463
464 template<class A1, class A2, class A3, class A4, class A5, class A6>
operator ()(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6) const465 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);
468 }
469
470 template<class A1, class A2, class A3, class A4, class A5, class A6,
471 class A7>
operator ()(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6,const A7 & a7) const472 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);
475 }
476
477 template<class A1, class A2, class A3, class A4, class A5, class A6,
478 class A7, class A8>
operator ()(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6,const A7 & a7,const A8 & a8) const479 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);
483 }
484
485 template<class A1, class A2, class A3, class A4, class A5, class A6,
486 class A7, class A8, class A9>
operator ()(const A1 & a1,const A2 & a2,const A3 & a3,const A4 & a4,const A5 & a5,const A6 & a6,const A7 & a7,const A8 & a8,const A9 & a9) const487 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);
491 }
492
493 };
494
495 // helper templates for return type deduction and action classes
496 // different cases for data member, function member, neither
497
498 // true-true case
499 template <bool Is_data_member, bool Is_function_member>
500 struct member_pointer_action_helper;
501 // cannot be both, no body provided
502
503 // data member case
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
506 template <>
507 struct member_pointer_action_helper<true, false> {
508 public:
509
510 template<class RET, class A, class B>
applyboost::lambda::detail::member_pointer_action_helper511 static RET apply(A& a, B& b) {
512 return a->*b;
513 }
514
515 template<class A, class B>
516 struct return_type {
517 private:
518 typedef typename detail::remove_reference_and_cv<B>::type plainB;
519
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;
523
524 // A is a reference to pointer
525 // remove the top level cv qualifiers and reference
526 typedef typename
527 detail::remove_reference_and_cv<A>::type non_ref_A;
528
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;
531
532 public:
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,
540 type1
541 >::RET type2;
542 typedef typename detail::IF<
543 ::boost::is_volatile<non_pointer_A>::value,
544 typename ::boost::add_volatile<type2>::type,
545 type2
546 >::RET type3;
547 // add reference back
548 typedef typename ::boost::add_reference<type3>::type type;
549 };
550 };
551
552 // neither case
553 template <>
554 struct member_pointer_action_helper<false, false> {
555 public:
556 template<class RET, class A, class B>
applyboost::lambda::detail::member_pointer_action_helper557 static RET apply(A& a, B& b) {
558 // not a built in member pointer operator, just call ->*
559 return a->*b;
560 }
561 // an overloaded member pointer operators, user should have specified
562 // the return type
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>
566 struct return_type {
567
568 typedef typename plain_return_type_2<
569 other_action<member_pointer_action>, A, B
570 >::type type;
571 };
572
573 };
574
575
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 ->*
581 template <>
582 struct member_pointer_action_helper<false, true> {
583 public:
584
585 template<class RET, class A, class B>
applyboost::lambda::detail::member_pointer_action_helper586 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;
590
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
594 // difference)
595 return detail::member_pointer_caller<ret_t, plainA, plainB>(a, b);
596 }
597
598 template<class A, class B>
599 struct return_type {
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;
603
604 typedef detail::member_pointer_caller<ret_t, plainA, plainB> type;
605 };
606 };
607
608 } // detail
609
610 template<> class other_action<member_pointer_action> {
611 public:
612 template<class RET, class A, class B>
apply(A & a,B & b)613 static RET apply(A& a, B& b) {
614 typedef typename
615 ::boost::remove_cv<B>::type plainB;
616
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);
623 }
624 };
625
626 // return type deduction --
627
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
631
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)
635
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
640
641
642 template<class A, class B>
643 struct return_type_2<other_action<member_pointer_action>, A, B> {
644 private:
645 typedef typename
646 detail::remove_reference_and_cv<B>::type plainB;
647 public:
648 typedef typename
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;
653 };
654
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.
658 template<class Args>
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;
662 typedef typename
663 return_type_2<other_action<member_pointer_action>,
664 typename boost::remove_reference<A>::type,
665 typename boost::remove_reference<B>::type
666 >::type type;
667 };
668
669
670 template<class Arg1, class Arg2>
671 inline const
672 lambda_functor<
673 lambda_functor_base<
674 action<2, other_action<member_pointer_action> >,
675 tuple<lambda_functor<Arg1>, typename const_copy_argument<Arg2>::type>
676 >
677 >
operator ->*(const lambda_functor<Arg1> & a1,const Arg2 & a2)678 operator->*(const lambda_functor<Arg1>& a1, const Arg2& a2)
679 {
680 return
681 lambda_functor_base<
682 action<2, other_action<member_pointer_action> >,
683 tuple<lambda_functor<Arg1>, typename const_copy_argument<Arg2>::type>
684 >
685 (tuple<lambda_functor<Arg1>,
686 typename const_copy_argument<Arg2>::type>(a1, a2));
687 }
688
689 template<class Arg1, class Arg2>
690 inline const
691 lambda_functor<
692 lambda_functor_base<
693 action<2, other_action<member_pointer_action> >,
694 tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
695 >
696 >
operator ->*(const lambda_functor<Arg1> & a1,const lambda_functor<Arg2> & a2)697 operator->*(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2)
698 {
699 return
700 lambda_functor_base<
701 action<2, other_action<member_pointer_action> >,
702 tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
703 >
704 (tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >(a1, a2));
705 }
706
707 template<class Arg1, class Arg2>
708 inline const
709 lambda_functor<
710 lambda_functor_base<
711 action<2, other_action<member_pointer_action> >,
712 tuple<typename const_copy_argument<Arg1>::type, lambda_functor<Arg2> >
713 >
714 >
operator ->*(const Arg1 & a1,const lambda_functor<Arg2> & a2)715 operator->*(const Arg1& a1, const lambda_functor<Arg2>& a2)
716 {
717 return
718 lambda_functor_base<
719 action<2, other_action<member_pointer_action> >,
720 tuple<typename const_copy_argument<Arg1>::type, lambda_functor<Arg2> >
721 >
722 (tuple<typename const_copy_argument<Arg1>::type,
723 lambda_functor<Arg2> >(a1, a2));
724 }
725
726
727 } // namespace lambda
728 } // namespace boost
729
730
731 #endif
732
733
734
735
736
737
738