1 | // operator_return_type_traits.hpp -- Boost Lambda Library ------------------ |
2 | |
3 | // Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) |
4 | // |
5 | // Distributed under the Boost Software License, Version 1.0. (See |
6 | // accompanying file LICENSE_1_0.txt or copy at |
7 | // http://www.boost.org/LICENSE_1_0.txt) |
8 | // |
9 | // For more information, see www.boost.org |
10 | |
11 | #ifndef BOOST_LAMBDA_OPERATOR_RETURN_TYPE_TRAITS_HPP |
12 | #define BOOST_LAMBDA_OPERATOR_RETURN_TYPE_TRAITS_HPP |
13 | |
14 | #include "boost/lambda/detail/is_instance_of.hpp" |
15 | #include "boost/type_traits/is_same.hpp" |
16 | #include "boost/type_traits/is_pointer.hpp" |
17 | #include "boost/type_traits/is_float.hpp" |
18 | #include "boost/type_traits/is_convertible.hpp" |
19 | #include "boost/type_traits/remove_pointer.hpp" |
20 | #include "boost/type_traits/remove_const.hpp" |
21 | #include "boost/type_traits/remove_reference.hpp" |
22 | |
23 | #include "boost/indirect_reference.hpp" |
24 | #include "boost/detail/container_fwd.hpp" |
25 | |
26 | #include <cstddef> // needed for the ptrdiff_t |
27 | #include <iosfwd> // for istream and ostream |
28 | |
29 | #include <iterator> // needed for operator& |
30 | |
31 | namespace boost { |
32 | namespace lambda { |
33 | namespace detail { |
34 | |
35 | // -- general helper templates for type deduction ------------------ |
36 | |
37 | // Much of the type deduction code for standard arithmetic types from Gary Powell |
38 | |
39 | template <class A> struct promote_code { static const int value = -1; }; |
40 | // this means that a code is not defined for A |
41 | |
42 | // -- the next 5 types are needed in if_then_else_return |
43 | // the promotion order is not important, but they must have distinct values. |
44 | template <> struct promote_code<bool> { static const int value = 10; }; |
45 | template <> struct promote_code<char> { static const int value = 20; }; |
46 | template <> struct promote_code<unsigned char> { static const int value = 30; }; |
47 | template <> struct promote_code<signed char> { static const int value = 40; }; |
48 | template <> struct promote_code<short int> { static const int value = 50; }; |
49 | // ---------- |
50 | |
51 | template <> struct promote_code<int> { static const int value = 100; }; |
52 | template <> struct promote_code<unsigned int> { static const int value = 200; }; |
53 | template <> struct promote_code<long> { static const int value = 300; }; |
54 | template <> struct promote_code<unsigned long> { static const int value = 400; }; |
55 | |
56 | template <> struct promote_code<float> { static const int value = 500; }; |
57 | template <> struct promote_code<double> { static const int value = 600; }; |
58 | template <> struct promote_code<long double> { static const int value = 700; }; |
59 | |
60 | // TODO: wchar_t |
61 | |
62 | // forward delcaration of complex. |
63 | |
64 | } // namespace detail |
65 | } // namespace lambda |
66 | } // namespace boost |
67 | |
68 | namespace boost { |
69 | namespace lambda { |
70 | namespace detail { |
71 | |
72 | template <> struct promote_code< std::complex<float> > { static const int value = 800; }; |
73 | template <> struct promote_code< std::complex<double> > { static const int value = 900; }; |
74 | template <> struct promote_code< std::complex<long double> > { static const int value = 1000; }; |
75 | |
76 | // -- int promotion ------------------------------------------- |
77 | template <class T> struct promote_to_int { typedef T type; }; |
78 | |
79 | template <> struct promote_to_int<bool> { typedef int type; }; |
80 | template <> struct promote_to_int<char> { typedef int type; }; |
81 | template <> struct promote_to_int<unsigned char> { typedef int type; }; |
82 | template <> struct promote_to_int<signed char> { typedef int type; }; |
83 | template <> struct promote_to_int<short int> { typedef int type; }; |
84 | |
85 | // The unsigned short int promotion rule is this: |
86 | // unsigned short int to signed int if a signed int can hold all values |
87 | // of unsigned short int, otherwise go to unsigned int. |
88 | template <> struct promote_to_int<unsigned short int> |
89 | { |
90 | typedef |
91 | detail::IF<sizeof(int) <= sizeof(unsigned short int), |
92 | // I had the logic reversed but ">" messes up the parsing. |
93 | unsigned int, |
94 | int>::RET type; |
95 | }; |
96 | |
97 | |
98 | // TODO: think, should there be default behaviour for non-standard types? |
99 | |
100 | } // namespace detail |
101 | |
102 | // ------------------------------------------ |
103 | // Unary actions ---------------------------- |
104 | // ------------------------------------------ |
105 | |
106 | template<class Act, class A> |
107 | struct plain_return_type_1 { |
108 | typedef detail::unspecified type; |
109 | }; |
110 | |
111 | |
112 | |
113 | template<class Act, class A> |
114 | struct plain_return_type_1<unary_arithmetic_action<Act>, A> { |
115 | typedef A type; |
116 | }; |
117 | |
118 | template<class Act, class A> |
119 | struct return_type_1<unary_arithmetic_action<Act>, A> { |
120 | typedef |
121 | typename plain_return_type_1< |
122 | unary_arithmetic_action<Act>, |
123 | typename detail::remove_reference_and_cv<A>::type |
124 | >::type type; |
125 | }; |
126 | |
127 | |
128 | template<class A> |
129 | struct plain_return_type_1<bitwise_action<not_action>, A> { |
130 | typedef A type; |
131 | }; |
132 | |
133 | // bitwise not, operator~() |
134 | template<class A> struct return_type_1<bitwise_action<not_action>, A> { |
135 | typedef |
136 | typename plain_return_type_1< |
137 | bitwise_action<not_action>, |
138 | typename detail::remove_reference_and_cv<A>::type |
139 | >::type type; |
140 | }; |
141 | |
142 | |
143 | // prefix increment and decrement operators return |
144 | // their argument by default as a non-const reference |
145 | template<class Act, class A> |
146 | struct plain_return_type_1<pre_increment_decrement_action<Act>, A> { |
147 | typedef A& type; |
148 | }; |
149 | |
150 | template<class Act, class A> |
151 | struct return_type_1<pre_increment_decrement_action<Act>, A> { |
152 | typedef |
153 | typename plain_return_type_1< |
154 | pre_increment_decrement_action<Act>, |
155 | typename detail::remove_reference_and_cv<A>::type |
156 | >::type type; |
157 | }; |
158 | |
159 | // post decrement just returns the same plain type. |
160 | template<class Act, class A> |
161 | struct plain_return_type_1<post_increment_decrement_action<Act>, A> { |
162 | typedef A type; |
163 | }; |
164 | |
165 | template<class Act, class A> |
166 | struct return_type_1<post_increment_decrement_action<Act>, A> |
167 | { |
168 | typedef |
169 | typename plain_return_type_1< |
170 | post_increment_decrement_action<Act>, |
171 | typename detail::remove_reference_and_cv<A>::type |
172 | >::type type; |
173 | }; |
174 | |
175 | // logical not, operator!() |
176 | template<class A> |
177 | struct plain_return_type_1<logical_action<not_action>, A> { |
178 | typedef bool type; |
179 | }; |
180 | |
181 | template<class A> |
182 | struct return_type_1<logical_action<not_action>, A> { |
183 | typedef |
184 | typename plain_return_type_1< |
185 | logical_action<not_action>, |
186 | typename detail::remove_reference_and_cv<A>::type |
187 | >::type type; |
188 | }; |
189 | |
190 | // address of action --------------------------------------- |
191 | |
192 | |
193 | template<class A> |
194 | struct return_type_1<other_action<addressof_action>, A> { |
195 | typedef |
196 | typename plain_return_type_1< |
197 | other_action<addressof_action>, |
198 | typename detail::remove_reference_and_cv<A>::type |
199 | >::type type1; |
200 | |
201 | // If no user defined specialization for A, then return the |
202 | // cv qualified pointer to A |
203 | typedef typename detail::IF< |
204 | boost::is_same<type1, detail::unspecified>::value, |
205 | typename boost::remove_reference<A>::type*, |
206 | type1 |
207 | >::RET type; |
208 | }; |
209 | |
210 | // contentsof action ------------------------------------ |
211 | |
212 | // TODO: this deduction may lead to fail directly, |
213 | // (if A has no specialization for iterator_traits and has no |
214 | // typedef A::reference. |
215 | // There is no easy way around this, cause there doesn't seem to be a way |
216 | // to test whether a class is an iterator or not. |
217 | |
218 | // The default works with std::iterators. |
219 | |
220 | namespace detail { |
221 | |
222 | // A is a nonreference type |
223 | template <class A> struct contentsof_type { |
224 | typedef typename boost::indirect_reference<A>::type type; |
225 | }; |
226 | |
227 | // this is since the nullary () in lambda_functor is always instantiated |
228 | template <> struct contentsof_type<null_type> { |
229 | typedef detail::unspecified type; |
230 | }; |
231 | |
232 | |
233 | template <class A> struct contentsof_type<const A> { |
234 | typedef typename contentsof_type<A>::type type; |
235 | }; |
236 | |
237 | template <class A> struct contentsof_type<volatile A> { |
238 | typedef typename contentsof_type<A>::type type; |
239 | }; |
240 | |
241 | template <class A> struct contentsof_type<const volatile A> { |
242 | typedef typename contentsof_type<A>::type type; |
243 | }; |
244 | |
245 | // standard iterator traits should take care of the pointer types |
246 | // but just to be on the safe side, we have the specializations here: |
247 | // these work even if A is cv-qualified. |
248 | template <class A> struct contentsof_type<A*> { |
249 | typedef A& type; |
250 | }; |
251 | template <class A> struct contentsof_type<A* const> { |
252 | typedef A& type; |
253 | }; |
254 | template <class A> struct contentsof_type<A* volatile> { |
255 | typedef A& type; |
256 | }; |
257 | template <class A> struct contentsof_type<A* const volatile> { |
258 | typedef A& type; |
259 | }; |
260 | |
261 | template<class A, int N> struct contentsof_type<A[N]> { |
262 | typedef A& type; |
263 | }; |
264 | template<class A, int N> struct contentsof_type<const A[N]> { |
265 | typedef const A& type; |
266 | }; |
267 | template<class A, int N> struct contentsof_type<volatile A[N]> { |
268 | typedef volatile A& type; |
269 | }; |
270 | template<class A, int N> struct contentsof_type<const volatile A[N]> { |
271 | typedef const volatile A& type; |
272 | }; |
273 | |
274 | |
275 | |
276 | |
277 | |
278 | } // end detail |
279 | |
280 | template<class A> |
281 | struct return_type_1<other_action<contentsof_action>, A> { |
282 | |
283 | typedef |
284 | typename plain_return_type_1< |
285 | other_action<contentsof_action>, |
286 | typename detail::remove_reference_and_cv<A>::type |
287 | >::type type1; |
288 | |
289 | // If no user defined specialization for A, then return the |
290 | // cv qualified pointer to A |
291 | typedef typename |
292 | detail::IF_type< |
293 | boost::is_same<type1, detail::unspecified>::value, |
294 | detail::contentsof_type< |
295 | typename boost::remove_reference<A>::type |
296 | >, |
297 | detail::identity_mapping<type1> |
298 | >::type type; |
299 | }; |
300 | |
301 | |
302 | // ------------------------------------------------------------------ |
303 | // binary actions --------------------------------------------------- |
304 | // ------------------------------------------------------------------ |
305 | |
306 | // here the default case is: no user defined versions: |
307 | template <class Act, class A, class B> |
308 | struct plain_return_type_2 { |
309 | typedef detail::unspecified type; |
310 | }; |
311 | |
312 | namespace detail { |
313 | |
314 | // error classes |
315 | class illegal_pointer_arithmetic{}; |
316 | |
317 | // pointer arithmetic type deductions ---------------------- |
318 | // value = false means that this is not a pointer arithmetic case |
319 | // value = true means, that this can be a pointer arithmetic case, but not necessarily is |
320 | // This means, that for user defined operators for pointer types, say for some operator+(X, *Y), |
321 | // the deductions must be coded at an earliel level (return_type_2). |
322 | |
323 | template<class Act, class A, class B> |
324 | struct pointer_arithmetic_traits { static const bool value = false; }; |
325 | |
326 | template<class A, class B> |
327 | struct pointer_arithmetic_traits<plus_action, A, B> { |
328 | |
329 | typedef typename |
330 | array_to_pointer<typename boost::remove_reference<A>::type>::type AP; |
331 | typedef typename |
332 | array_to_pointer<typename boost::remove_reference<B>::type>::type BP; |
333 | |
334 | static const bool is_pointer_A = boost::is_pointer<AP>::value; |
335 | static const bool is_pointer_B = boost::is_pointer<BP>::value; |
336 | |
337 | static const bool value = is_pointer_A || is_pointer_B; |
338 | |
339 | // can't add two pointers. |
340 | // note, that we do not check wether the other type is valid for |
341 | // addition with a pointer. |
342 | // the compiler will catch it in the apply function |
343 | |
344 | typedef typename |
345 | detail::IF< |
346 | is_pointer_A && is_pointer_B, |
347 | detail::return_type_deduction_failure< |
348 | detail::illegal_pointer_arithmetic |
349 | >, |
350 | typename detail::IF<is_pointer_A, AP, BP>::RET |
351 | >::RET type; |
352 | |
353 | }; |
354 | |
355 | template<class A, class B> |
356 | struct pointer_arithmetic_traits<minus_action, A, B> { |
357 | typedef typename |
358 | array_to_pointer<typename boost::remove_reference<A>::type>::type AP; |
359 | typedef typename |
360 | array_to_pointer<typename boost::remove_reference<B>::type>::type BP; |
361 | |
362 | static const bool is_pointer_A = boost::is_pointer<AP>::value; |
363 | static const bool is_pointer_B = boost::is_pointer<BP>::value; |
364 | |
365 | static const bool value = is_pointer_A || is_pointer_B; |
366 | |
367 | static const bool same_pointer_type = |
368 | is_pointer_A && is_pointer_B && |
369 | boost::is_same< |
370 | typename boost::remove_const< |
371 | typename boost::remove_pointer< |
372 | typename boost::remove_const<AP>::type |
373 | >::type |
374 | >::type, |
375 | typename boost::remove_const< |
376 | typename boost::remove_pointer< |
377 | typename boost::remove_const<BP>::type |
378 | >::type |
379 | >::type |
380 | >::value; |
381 | |
382 | // ptr - ptr has type ptrdiff_t |
383 | // note, that we do not check if, in ptr - B, B is |
384 | // valid for subtraction with a pointer. |
385 | // the compiler will catch it in the apply function |
386 | |
387 | typedef typename |
388 | detail::IF< |
389 | same_pointer_type, const std::ptrdiff_t, |
390 | typename detail::IF< |
391 | is_pointer_A, |
392 | AP, |
393 | detail::return_type_deduction_failure<detail::illegal_pointer_arithmetic> |
394 | >::RET |
395 | >::RET type; |
396 | }; |
397 | |
398 | } // namespace detail |
399 | |
400 | // -- arithmetic actions --------------------------------------------- |
401 | |
402 | namespace detail { |
403 | |
404 | template<bool is_pointer_arithmetic, class Act, class A, class B> |
405 | struct return_type_2_arithmetic_phase_1; |
406 | |
407 | template<class A, class B> struct return_type_2_arithmetic_phase_2; |
408 | template<class A, class B> struct return_type_2_arithmetic_phase_3; |
409 | |
410 | } // namespace detail |
411 | |
412 | |
413 | // drop any qualifiers from the argument types within arithmetic_action |
414 | template<class A, class B, class Act> |
415 | struct return_type_2<arithmetic_action<Act>, A, B> |
416 | { |
417 | typedef typename detail::remove_reference_and_cv<A>::type plain_A; |
418 | typedef typename detail::remove_reference_and_cv<B>::type plain_B; |
419 | |
420 | typedef typename |
421 | plain_return_type_2<arithmetic_action<Act>, plain_A, plain_B>::type type1; |
422 | |
423 | // if user defined return type, do not enter the whole arithmetic deductions |
424 | typedef typename |
425 | detail::IF_type< |
426 | boost::is_same<type1, detail::unspecified>::value, |
427 | detail::return_type_2_arithmetic_phase_1< |
428 | detail::pointer_arithmetic_traits<Act, A, B>::value, Act, A, B |
429 | >, |
430 | plain_return_type_2<arithmetic_action<Act>, plain_A, plain_B> |
431 | >::type type; |
432 | }; |
433 | |
434 | namespace detail { |
435 | |
436 | // perform integral promotion, no pointer arithmetic |
437 | template<bool is_pointer_arithmetic, class Act, class A, class B> |
438 | struct return_type_2_arithmetic_phase_1 |
439 | { |
440 | typedef typename |
441 | return_type_2_arithmetic_phase_2< |
442 | typename remove_reference_and_cv<A>::type, |
443 | typename remove_reference_and_cv<B>::type |
444 | >::type type; |
445 | }; |
446 | |
447 | // pointer_arithmetic |
448 | template<class Act, class A, class B> |
449 | struct return_type_2_arithmetic_phase_1<true, Act, A, B> |
450 | { |
451 | typedef typename |
452 | pointer_arithmetic_traits<Act, A, B>::type type; |
453 | }; |
454 | |
455 | template<class A, class B> |
456 | struct return_type_2_arithmetic_phase_2 { |
457 | typedef typename |
458 | return_type_2_arithmetic_phase_3< |
459 | typename promote_to_int<A>::type, |
460 | typename promote_to_int<B>::type |
461 | >::type type; |
462 | }; |
463 | |
464 | // specialization for unsigned int. |
465 | // We only have to do these two specialization because the value promotion will |
466 | // take care of the other cases. |
467 | // The unsigned int promotion rule is this: |
468 | // unsigned int to long if a long can hold all values of unsigned int, |
469 | // otherwise go to unsigned long. |
470 | |
471 | // struct so I don't have to type this twice. |
472 | struct promotion_of_unsigned_int |
473 | { |
474 | typedef |
475 | detail::IF<sizeof(long) <= sizeof(unsigned int), |
476 | unsigned long, |
477 | long>::RET type; |
478 | }; |
479 | |
480 | template<> |
481 | struct return_type_2_arithmetic_phase_2<unsigned int, long> |
482 | { |
483 | typedef promotion_of_unsigned_int::type type; |
484 | }; |
485 | template<> |
486 | struct return_type_2_arithmetic_phase_2<long, unsigned int> |
487 | { |
488 | typedef promotion_of_unsigned_int::type type; |
489 | }; |
490 | |
491 | |
492 | template<class A, class B> struct return_type_2_arithmetic_phase_3 { |
493 | enum { promote_code_A_value = promote_code<A>::value, |
494 | promote_code_B_value = promote_code<B>::value }; // enums for KCC |
495 | typedef typename |
496 | detail::IF< |
497 | promote_code_A_value == -1 || promote_code_B_value == -1, |
498 | detail::return_type_deduction_failure<return_type_2_arithmetic_phase_3>, |
499 | typename detail::IF< |
500 | ((int)promote_code_A_value > (int)promote_code_B_value), |
501 | A, |
502 | B |
503 | >::RET |
504 | >::RET type; |
505 | }; |
506 | |
507 | } // namespace detail |
508 | |
509 | // -- bitwise actions ------------------------------------------- |
510 | // note: for integral types deuduction is similar to arithmetic actions. |
511 | |
512 | // drop any qualifiers from the argument types within arithmetic action |
513 | template<class A, class B, class Act> |
514 | struct return_type_2<bitwise_action<Act>, A, B> |
515 | { |
516 | |
517 | typedef typename detail::remove_reference_and_cv<A>::type plain_A; |
518 | typedef typename detail::remove_reference_and_cv<B>::type plain_B; |
519 | |
520 | typedef typename |
521 | plain_return_type_2<bitwise_action<Act>, plain_A, plain_B>::type type1; |
522 | |
523 | // if user defined return type, do not enter type deductions |
524 | typedef typename |
525 | detail::IF_type< |
526 | boost::is_same<type1, detail::unspecified>::value, |
527 | return_type_2<arithmetic_action<plus_action>, A, B>, |
528 | plain_return_type_2<bitwise_action<Act>, plain_A, plain_B> |
529 | >::type type; |
530 | |
531 | // plus_action is just a random pick, has to be a concrete instance |
532 | |
533 | // TODO: This check is only valid for built-in types, overloaded types might |
534 | // accept floating point operators |
535 | |
536 | // bitwise operators not defined for floating point types |
537 | // these test are not strictly needed here, since the error will be caught in |
538 | // the apply function |
539 | BOOST_STATIC_ASSERT(!(boost::is_float<plain_A>::value && boost::is_float<plain_B>::value)); |
540 | |
541 | }; |
542 | |
543 | namespace detail { |
544 | |
545 | |
546 | template <class T> struct get_ostream_type { |
547 | typedef std::basic_ostream<typename T::char_type, |
548 | typename T::traits_type>& type; |
549 | }; |
550 | |
551 | template <class T> struct get_istream_type { |
552 | typedef std::basic_istream<typename T::char_type, |
553 | typename T::traits_type>& type; |
554 | }; |
555 | |
556 | template<class A, class B> |
557 | struct leftshift_type { |
558 | private: |
559 | typedef typename boost::remove_reference<A>::type plainA; |
560 | public: |
561 | typedef typename detail::IF_type< |
562 | is_instance_of_2<plainA, std::basic_ostream>::value, |
563 | get_ostream_type<plainA>, //reference to the stream |
564 | detail::remove_reference_and_cv<A> |
565 | >::type type; |
566 | }; |
567 | |
568 | template<class A, class B> |
569 | struct rightshift_type { |
570 | private: |
571 | typedef typename boost::remove_reference<A>::type plainA; |
572 | public: |
573 | typedef typename detail::IF_type< |
574 | is_instance_of_2<plainA, std::basic_istream>::value, |
575 | get_istream_type<plainA>, //reference to the stream |
576 | detail::remove_reference_and_cv<A> |
577 | >::type type; |
578 | }; |
579 | |
580 | |
581 | |
582 | } // end detail |
583 | |
584 | // ostream |
585 | template<class A, class B> |
586 | struct return_type_2<bitwise_action<leftshift_action>, A, B> |
587 | { |
588 | typedef typename detail::remove_reference_and_cv<A>::type plain_A; |
589 | typedef typename detail::remove_reference_and_cv<B>::type plain_B; |
590 | |
591 | typedef typename |
592 | plain_return_type_2<bitwise_action<leftshift_action>, plain_A, plain_B>::type type1; |
593 | |
594 | // if user defined return type, do not enter type deductions |
595 | typedef typename |
596 | detail::IF_type< |
597 | boost::is_same<type1, detail::unspecified>::value, |
598 | detail::leftshift_type<A, B>, |
599 | plain_return_type_2<bitwise_action<leftshift_action>, plain_A, plain_B> |
600 | >::type type; |
601 | }; |
602 | |
603 | // istream |
604 | template<class A, class B> |
605 | struct return_type_2<bitwise_action<rightshift_action>, A, B> |
606 | { |
607 | typedef typename detail::remove_reference_and_cv<A>::type plain_A; |
608 | typedef typename detail::remove_reference_and_cv<B>::type plain_B; |
609 | |
610 | typedef typename |
611 | plain_return_type_2<bitwise_action<rightshift_action>, plain_A, plain_B>::type type1; |
612 | |
613 | // if user defined return type, do not enter type deductions |
614 | typedef typename |
615 | detail::IF_type< |
616 | boost::is_same<type1, detail::unspecified>::value, |
617 | detail::rightshift_type<A, B>, |
618 | plain_return_type_2<bitwise_action<rightshift_action>, plain_A, plain_B> |
619 | >::type type; |
620 | }; |
621 | |
622 | // -- logical actions ---------------------------------------- |
623 | // always bool |
624 | // NOTE: this may not be true for some weird user-defined types, |
625 | template<class A, class B, class Act> |
626 | struct plain_return_type_2<logical_action<Act>, A, B> { |
627 | typedef bool type; |
628 | }; |
629 | |
630 | template<class A, class B, class Act> |
631 | struct return_type_2<logical_action<Act>, A, B> { |
632 | |
633 | typedef typename detail::remove_reference_and_cv<A>::type plain_A; |
634 | typedef typename detail::remove_reference_and_cv<B>::type plain_B; |
635 | |
636 | typedef typename |
637 | plain_return_type_2<logical_action<Act>, plain_A, plain_B>::type type; |
638 | |
639 | }; |
640 | |
641 | |
642 | // -- relational actions ---------------------------------------- |
643 | // always bool |
644 | // NOTE: this may not be true for some weird user-defined types, |
645 | template<class A, class B, class Act> |
646 | struct plain_return_type_2<relational_action<Act>, A, B> { |
647 | typedef bool type; |
648 | }; |
649 | |
650 | template<class A, class B, class Act> |
651 | struct return_type_2<relational_action<Act>, A, B> { |
652 | |
653 | typedef typename detail::remove_reference_and_cv<A>::type plain_A; |
654 | typedef typename detail::remove_reference_and_cv<B>::type plain_B; |
655 | |
656 | typedef typename |
657 | plain_return_type_2<relational_action<Act>, plain_A, plain_B>::type type; |
658 | }; |
659 | |
660 | // Assingment actions ----------------------------------------------- |
661 | // return type is the type of the first argument as reference |
662 | |
663 | // note that cv-qualifiers are preserved. |
664 | // Yes, assignment operator can be const! |
665 | |
666 | // NOTE: this may not be true for some weird user-defined types, |
667 | |
668 | template<class A, class B, class Act> |
669 | struct return_type_2<arithmetic_assignment_action<Act>, A, B> { |
670 | |
671 | typedef typename detail::remove_reference_and_cv<A>::type plain_A; |
672 | typedef typename detail::remove_reference_and_cv<B>::type plain_B; |
673 | |
674 | typedef typename |
675 | plain_return_type_2< |
676 | arithmetic_assignment_action<Act>, plain_A, plain_B |
677 | >::type type1; |
678 | |
679 | typedef typename |
680 | detail::IF< |
681 | boost::is_same<type1, detail::unspecified>::value, |
682 | typename boost::add_reference<A>::type, |
683 | type1 |
684 | >::RET type; |
685 | }; |
686 | |
687 | template<class A, class B, class Act> |
688 | struct return_type_2<bitwise_assignment_action<Act>, A, B> { |
689 | |
690 | typedef typename detail::remove_reference_and_cv<A>::type plain_A; |
691 | typedef typename detail::remove_reference_and_cv<B>::type plain_B; |
692 | |
693 | typedef typename |
694 | plain_return_type_2< |
695 | bitwise_assignment_action<Act>, plain_A, plain_B |
696 | >::type type1; |
697 | |
698 | typedef typename |
699 | detail::IF< |
700 | boost::is_same<type1, detail::unspecified>::value, |
701 | typename boost::add_reference<A>::type, |
702 | type1 |
703 | >::RET type; |
704 | }; |
705 | |
706 | template<class A, class B> |
707 | struct return_type_2<other_action<assignment_action>, A, B> { |
708 | typedef typename detail::remove_reference_and_cv<A>::type plain_A; |
709 | typedef typename detail::remove_reference_and_cv<B>::type plain_B; |
710 | |
711 | typedef typename |
712 | plain_return_type_2< |
713 | other_action<assignment_action>, plain_A, plain_B |
714 | >::type type1; |
715 | |
716 | typedef typename |
717 | detail::IF< |
718 | boost::is_same<type1, detail::unspecified>::value, |
719 | typename boost::add_reference<A>::type, |
720 | type1 |
721 | >::RET type; |
722 | }; |
723 | |
724 | // -- other actions ---------------------------------------- |
725 | |
726 | // comma action ---------------------------------- |
727 | // Note: this may not be true for some weird user-defined types, |
728 | |
729 | // NOTE! This only tries the plain_return_type_2 layer and gives |
730 | // detail::unspecified as default. If no such specialization is found, the |
731 | // type rule in the spcecialization of the return_type_2_prot is used |
732 | // to give the type of the right argument (which can be a reference too) |
733 | // (The built in operator, can return a l- or rvalue). |
734 | template<class A, class B> |
735 | struct return_type_2<other_action<comma_action>, A, B> { |
736 | |
737 | typedef typename detail::remove_reference_and_cv<A>::type plain_A; |
738 | typedef typename detail::remove_reference_and_cv<B>::type plain_B; |
739 | |
740 | typedef typename |
741 | plain_return_type_2< |
742 | other_action<comma_action>, plain_A, plain_B |
743 | >::type type; |
744 | }; |
745 | |
746 | // subscript action ----------------------------------------------- |
747 | |
748 | |
749 | namespace detail { |
750 | // A and B are nonreference types |
751 | template <class A, class B> struct subscript_type { |
752 | typedef detail::unspecified type; |
753 | }; |
754 | |
755 | template <class A, class B> struct subscript_type<A*, B> { |
756 | typedef A& type; |
757 | }; |
758 | template <class A, class B> struct subscript_type<A* const, B> { |
759 | typedef A& type; |
760 | }; |
761 | template <class A, class B> struct subscript_type<A* volatile, B> { |
762 | typedef A& type; |
763 | }; |
764 | template <class A, class B> struct subscript_type<A* const volatile, B> { |
765 | typedef A& type; |
766 | }; |
767 | |
768 | |
769 | template<class A, class B, int N> struct subscript_type<A[N], B> { |
770 | typedef A& type; |
771 | }; |
772 | |
773 | // these 3 specializations are needed to make gcc <3 happy |
774 | template<class A, class B, int N> struct subscript_type<const A[N], B> { |
775 | typedef const A& type; |
776 | }; |
777 | template<class A, class B, int N> struct subscript_type<volatile A[N], B> { |
778 | typedef volatile A& type; |
779 | }; |
780 | template<class A, class B, int N> struct subscript_type<const volatile A[N], B> { |
781 | typedef const volatile A& type; |
782 | }; |
783 | |
784 | } // end detail |
785 | |
786 | template<class A, class B> |
787 | struct return_type_2<other_action<subscript_action>, A, B> { |
788 | |
789 | typedef typename detail::remove_reference_and_cv<A>::type plain_A; |
790 | typedef typename detail::remove_reference_and_cv<B>::type plain_B; |
791 | |
792 | typedef typename boost::remove_reference<A>::type nonref_A; |
793 | typedef typename boost::remove_reference<B>::type nonref_B; |
794 | |
795 | typedef typename |
796 | plain_return_type_2< |
797 | other_action<subscript_action>, plain_A, plain_B |
798 | >::type type1; |
799 | |
800 | typedef typename |
801 | detail::IF_type< |
802 | boost::is_same<type1, detail::unspecified>::value, |
803 | detail::subscript_type<nonref_A, nonref_B>, |
804 | plain_return_type_2<other_action<subscript_action>, plain_A, plain_B> |
805 | >::type type; |
806 | |
807 | }; |
808 | |
809 | template<class Key, class T, class Cmp, class Allocator, class B> |
810 | struct plain_return_type_2<other_action<subscript_action>, std::map<Key, T, Cmp, Allocator>, B> { |
811 | typedef T& type; |
812 | // T == std::map<Key, T, Cmp, Allocator>::mapped_type; |
813 | }; |
814 | |
815 | template<class Key, class T, class Cmp, class Allocator, class B> |
816 | struct plain_return_type_2<other_action<subscript_action>, std::multimap<Key, T, Cmp, Allocator>, B> { |
817 | typedef T& type; |
818 | // T == std::map<Key, T, Cmp, Allocator>::mapped_type; |
819 | }; |
820 | |
821 | // deque |
822 | template<class T, class Allocator, class B> |
823 | struct plain_return_type_2<other_action<subscript_action>, std::deque<T, Allocator>, B> { |
824 | typedef typename std::deque<T, Allocator>::reference type; |
825 | }; |
826 | template<class T, class Allocator, class B> |
827 | struct plain_return_type_2<other_action<subscript_action>, const std::deque<T, Allocator>, B> { |
828 | typedef typename std::deque<T, Allocator>::const_reference type; |
829 | }; |
830 | |
831 | // vector |
832 | template<class T, class Allocator, class B> |
833 | struct plain_return_type_2<other_action<subscript_action>, std::vector<T, Allocator>, B> { |
834 | typedef typename std::vector<T, Allocator>::reference type; |
835 | }; |
836 | template<class T, class Allocator, class B> |
837 | struct plain_return_type_2<other_action<subscript_action>, const std::vector<T, Allocator>, B> { |
838 | typedef typename std::vector<T, Allocator>::const_reference type; |
839 | }; |
840 | |
841 | // basic_string |
842 | template<class Char, class Traits, class Allocator, class B> |
843 | struct plain_return_type_2<other_action<subscript_action>, std::basic_string<Char, Traits, Allocator>, B> { |
844 | typedef typename std::basic_string<Char, Traits, Allocator>::reference type; |
845 | }; |
846 | template<class Char, class Traits, class Allocator, class B> |
847 | struct plain_return_type_2<other_action<subscript_action>, const std::basic_string<Char, Traits, Allocator>, B> { |
848 | typedef typename std::basic_string<Char, Traits, Allocator>::const_reference type; |
849 | }; |
850 | |
851 | template<class Char, class Traits, class Allocator> |
852 | struct plain_return_type_2<arithmetic_action<plus_action>, |
853 | std::basic_string<Char, Traits, Allocator>, |
854 | std::basic_string<Char, Traits, Allocator> > { |
855 | typedef std::basic_string<Char, Traits, Allocator> type; |
856 | }; |
857 | |
858 | template<class Char, class Traits, class Allocator> |
859 | struct plain_return_type_2<arithmetic_action<plus_action>, |
860 | const Char*, |
861 | std::basic_string<Char, Traits, Allocator> > { |
862 | typedef std::basic_string<Char, Traits, Allocator> type; |
863 | }; |
864 | |
865 | template<class Char, class Traits, class Allocator> |
866 | struct plain_return_type_2<arithmetic_action<plus_action>, |
867 | std::basic_string<Char, Traits, Allocator>, |
868 | const Char*> { |
869 | typedef std::basic_string<Char, Traits, Allocator> type; |
870 | }; |
871 | |
872 | template<class Char, class Traits, class Allocator, std::size_t N> |
873 | struct plain_return_type_2<arithmetic_action<plus_action>, |
874 | Char[N], |
875 | std::basic_string<Char, Traits, Allocator> > { |
876 | typedef std::basic_string<Char, Traits, Allocator> type; |
877 | }; |
878 | |
879 | template<class Char, class Traits, class Allocator, std::size_t N> |
880 | struct plain_return_type_2<arithmetic_action<plus_action>, |
881 | std::basic_string<Char, Traits, Allocator>, |
882 | Char[N]> { |
883 | typedef std::basic_string<Char, Traits, Allocator> type; |
884 | }; |
885 | |
886 | |
887 | } // namespace lambda |
888 | } // namespace boost |
889 | |
890 | #endif |
891 | |
892 | |
893 | |