1//
2//! Copyright (c) 2011-2012
3//! Brandon Kohn
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
10
11
12namespace boost { namespace numeric {
13
14 template <>
15 struct numeric_cast_traits
16 <
17 char
18 , char
19 >
20 {
21 typedef def_overflow_handler overflow_policy;
22 typedef UseInternalRangeChecker range_checking_policy;
23 typedef Trunc<char> rounding_policy;
24 };
25
26 template <>
27 struct numeric_cast_traits
28 <
29 char
30 , signed char
31 >
32 {
33 typedef def_overflow_handler overflow_policy;
34 typedef UseInternalRangeChecker range_checking_policy;
35 typedef Trunc<signed char> rounding_policy;
36 };
37
38 template <>
39 struct numeric_cast_traits
40 <
41 char
42 , unsigned char
43 >
44 {
45 typedef def_overflow_handler overflow_policy;
46 typedef UseInternalRangeChecker range_checking_policy;
47 typedef Trunc<unsigned char> rounding_policy;
48 };
49
50 template <>
51 struct numeric_cast_traits
52 <
53 char
54 , short
55 >
56 {
57 typedef def_overflow_handler overflow_policy;
58 typedef UseInternalRangeChecker range_checking_policy;
59 typedef Trunc<short> rounding_policy;
60 };
61
62 template <>
63 struct numeric_cast_traits
64 <
65 char
66 , unsigned short
67 >
68 {
69 typedef def_overflow_handler overflow_policy;
70 typedef UseInternalRangeChecker range_checking_policy;
71 typedef Trunc<unsigned short> rounding_policy;
72 };
73
74 template <>
75 struct numeric_cast_traits
76 <
77 char
78 , int
79 >
80 {
81 typedef def_overflow_handler overflow_policy;
82 typedef UseInternalRangeChecker range_checking_policy;
83 typedef Trunc<int> rounding_policy;
84 };
85
86 template <>
87 struct numeric_cast_traits
88 <
89 char
90 , unsigned int
91 >
92 {
93 typedef def_overflow_handler overflow_policy;
94 typedef UseInternalRangeChecker range_checking_policy;
95 typedef Trunc<unsigned int> rounding_policy;
96 };
97
98 template <>
99 struct numeric_cast_traits
100 <
101 char
102 , long
103 >
104 {
105 typedef def_overflow_handler overflow_policy;
106 typedef UseInternalRangeChecker range_checking_policy;
107 typedef Trunc<long> rounding_policy;
108 };
109
110 template <>
111 struct numeric_cast_traits
112 <
113 char
114 , unsigned long
115 >
116 {
117 typedef def_overflow_handler overflow_policy;
118 typedef UseInternalRangeChecker range_checking_policy;
119 typedef Trunc<unsigned long> rounding_policy;
120 };
121
122 template <>
123 struct numeric_cast_traits
124 <
125 char
126 , float
127 >
128 {
129 typedef def_overflow_handler overflow_policy;
130 typedef UseInternalRangeChecker range_checking_policy;
131 typedef Trunc<float> rounding_policy;
132 };
133
134 template <>
135 struct numeric_cast_traits
136 <
137 char
138 , double
139 >
140 {
141 typedef def_overflow_handler overflow_policy;
142 typedef UseInternalRangeChecker range_checking_policy;
143 typedef Trunc<double> rounding_policy;
144 };
145
146 template <>
147 struct numeric_cast_traits
148 <
149 char
150 , long double
151 >
152 {
153 typedef def_overflow_handler overflow_policy;
154 typedef UseInternalRangeChecker range_checking_policy;
155 typedef Trunc<long double> rounding_policy;
156 };
157
158 template <>
159 struct numeric_cast_traits
160 <
161 signed char
162 , char
163 >
164 {
165 typedef def_overflow_handler overflow_policy;
166 typedef UseInternalRangeChecker range_checking_policy;
167 typedef Trunc<char> rounding_policy;
168 };
169
170 template <>
171 struct numeric_cast_traits
172 <
173 signed char
174 , signed char
175 >
176 {
177 typedef def_overflow_handler overflow_policy;
178 typedef UseInternalRangeChecker range_checking_policy;
179 typedef Trunc<signed char> rounding_policy;
180 };
181
182 template <>
183 struct numeric_cast_traits
184 <
185 signed char
186 , unsigned char
187 >
188 {
189 typedef def_overflow_handler overflow_policy;
190 typedef UseInternalRangeChecker range_checking_policy;
191 typedef Trunc<unsigned char> rounding_policy;
192 };
193
194 template <>
195 struct numeric_cast_traits
196 <
197 signed char
198 , short
199 >
200 {
201 typedef def_overflow_handler overflow_policy;
202 typedef UseInternalRangeChecker range_checking_policy;
203 typedef Trunc<short> rounding_policy;
204 };
205
206 template <>
207 struct numeric_cast_traits
208 <
209 signed char
210 , unsigned short
211 >
212 {
213 typedef def_overflow_handler overflow_policy;
214 typedef UseInternalRangeChecker range_checking_policy;
215 typedef Trunc<unsigned short> rounding_policy;
216 };
217
218 template <>
219 struct numeric_cast_traits
220 <
221 signed char
222 , int
223 >
224 {
225 typedef def_overflow_handler overflow_policy;
226 typedef UseInternalRangeChecker range_checking_policy;
227 typedef Trunc<int> rounding_policy;
228 };
229
230 template <>
231 struct numeric_cast_traits
232 <
233 signed char
234 , unsigned int
235 >
236 {
237 typedef def_overflow_handler overflow_policy;
238 typedef UseInternalRangeChecker range_checking_policy;
239 typedef Trunc<unsigned int> rounding_policy;
240 };
241
242 template <>
243 struct numeric_cast_traits
244 <
245 signed char
246 , long
247 >
248 {
249 typedef def_overflow_handler overflow_policy;
250 typedef UseInternalRangeChecker range_checking_policy;
251 typedef Trunc<long> rounding_policy;
252 };
253
254 template <>
255 struct numeric_cast_traits
256 <
257 signed char
258 , unsigned long
259 >
260 {
261 typedef def_overflow_handler overflow_policy;
262 typedef UseInternalRangeChecker range_checking_policy;
263 typedef Trunc<unsigned long> rounding_policy;
264 };
265
266 template <>
267 struct numeric_cast_traits
268 <
269 signed char
270 , float
271 >
272 {
273 typedef def_overflow_handler overflow_policy;
274 typedef UseInternalRangeChecker range_checking_policy;
275 typedef Trunc<float> rounding_policy;
276 };
277
278 template <>
279 struct numeric_cast_traits
280 <
281 signed char
282 , double
283 >
284 {
285 typedef def_overflow_handler overflow_policy;
286 typedef UseInternalRangeChecker range_checking_policy;
287 typedef Trunc<double> rounding_policy;
288 };
289
290 template <>
291 struct numeric_cast_traits
292 <
293 signed char
294 , long double
295 >
296 {
297 typedef def_overflow_handler overflow_policy;
298 typedef UseInternalRangeChecker range_checking_policy;
299 typedef Trunc<long double> rounding_policy;
300 };
301
302 template <>
303 struct numeric_cast_traits
304 <
305 unsigned char
306 , char
307 >
308 {
309 typedef def_overflow_handler overflow_policy;
310 typedef UseInternalRangeChecker range_checking_policy;
311 typedef Trunc<char> rounding_policy;
312 };
313
314 template <>
315 struct numeric_cast_traits
316 <
317 unsigned char
318 , signed char
319 >
320 {
321 typedef def_overflow_handler overflow_policy;
322 typedef UseInternalRangeChecker range_checking_policy;
323 typedef Trunc<signed char> rounding_policy;
324 };
325
326 template <>
327 struct numeric_cast_traits
328 <
329 unsigned char
330 , unsigned char
331 >
332 {
333 typedef def_overflow_handler overflow_policy;
334 typedef UseInternalRangeChecker range_checking_policy;
335 typedef Trunc<unsigned char> rounding_policy;
336 };
337
338 template <>
339 struct numeric_cast_traits
340 <
341 unsigned char
342 , short
343 >
344 {
345 typedef def_overflow_handler overflow_policy;
346 typedef UseInternalRangeChecker range_checking_policy;
347 typedef Trunc<short> rounding_policy;
348 };
349
350 template <>
351 struct numeric_cast_traits
352 <
353 unsigned char
354 , unsigned short
355 >
356 {
357 typedef def_overflow_handler overflow_policy;
358 typedef UseInternalRangeChecker range_checking_policy;
359 typedef Trunc<unsigned short> rounding_policy;
360 };
361
362 template <>
363 struct numeric_cast_traits
364 <
365 unsigned char
366 , int
367 >
368 {
369 typedef def_overflow_handler overflow_policy;
370 typedef UseInternalRangeChecker range_checking_policy;
371 typedef Trunc<int> rounding_policy;
372 };
373
374 template <>
375 struct numeric_cast_traits
376 <
377 unsigned char
378 , unsigned int
379 >
380 {
381 typedef def_overflow_handler overflow_policy;
382 typedef UseInternalRangeChecker range_checking_policy;
383 typedef Trunc<unsigned int> rounding_policy;
384 };
385
386 template <>
387 struct numeric_cast_traits
388 <
389 unsigned char
390 , long
391 >
392 {
393 typedef def_overflow_handler overflow_policy;
394 typedef UseInternalRangeChecker range_checking_policy;
395 typedef Trunc<long> rounding_policy;
396 };
397
398 template <>
399 struct numeric_cast_traits
400 <
401 unsigned char
402 , unsigned long
403 >
404 {
405 typedef def_overflow_handler overflow_policy;
406 typedef UseInternalRangeChecker range_checking_policy;
407 typedef Trunc<unsigned long> rounding_policy;
408 };
409
410 template <>
411 struct numeric_cast_traits
412 <
413 unsigned char
414 , float
415 >
416 {
417 typedef def_overflow_handler overflow_policy;
418 typedef UseInternalRangeChecker range_checking_policy;
419 typedef Trunc<float> rounding_policy;
420 };
421
422 template <>
423 struct numeric_cast_traits
424 <
425 unsigned char
426 , double
427 >
428 {
429 typedef def_overflow_handler overflow_policy;
430 typedef UseInternalRangeChecker range_checking_policy;
431 typedef Trunc<double> rounding_policy;
432 };
433
434 template <>
435 struct numeric_cast_traits
436 <
437 unsigned char
438 , long double
439 >
440 {
441 typedef def_overflow_handler overflow_policy;
442 typedef UseInternalRangeChecker range_checking_policy;
443 typedef Trunc<long double> rounding_policy;
444 };
445
446 template <>
447 struct numeric_cast_traits
448 <
449 short
450 , char
451 >
452 {
453 typedef def_overflow_handler overflow_policy;
454 typedef UseInternalRangeChecker range_checking_policy;
455 typedef Trunc<char> rounding_policy;
456 };
457
458 template <>
459 struct numeric_cast_traits
460 <
461 short
462 , signed char
463 >
464 {
465 typedef def_overflow_handler overflow_policy;
466 typedef UseInternalRangeChecker range_checking_policy;
467 typedef Trunc<signed char> rounding_policy;
468 };
469
470 template <>
471 struct numeric_cast_traits
472 <
473 short
474 , unsigned char
475 >
476 {
477 typedef def_overflow_handler overflow_policy;
478 typedef UseInternalRangeChecker range_checking_policy;
479 typedef Trunc<unsigned char> rounding_policy;
480 };
481
482 template <>
483 struct numeric_cast_traits
484 <
485 short
486 , short
487 >
488 {
489 typedef def_overflow_handler overflow_policy;
490 typedef UseInternalRangeChecker range_checking_policy;
491 typedef Trunc<short> rounding_policy;
492 };
493
494 template <>
495 struct numeric_cast_traits
496 <
497 short
498 , unsigned short
499 >
500 {
501 typedef def_overflow_handler overflow_policy;
502 typedef UseInternalRangeChecker range_checking_policy;
503 typedef Trunc<unsigned short> rounding_policy;
504 };
505
506 template <>
507 struct numeric_cast_traits
508 <
509 short
510 , int
511 >
512 {
513 typedef def_overflow_handler overflow_policy;
514 typedef UseInternalRangeChecker range_checking_policy;
515 typedef Trunc<int> rounding_policy;
516 };
517
518 template <>
519 struct numeric_cast_traits
520 <
521 short
522 , unsigned int
523 >
524 {
525 typedef def_overflow_handler overflow_policy;
526 typedef UseInternalRangeChecker range_checking_policy;
527 typedef Trunc<unsigned int> rounding_policy;
528 };
529
530 template <>
531 struct numeric_cast_traits
532 <
533 short
534 , long
535 >
536 {
537 typedef def_overflow_handler overflow_policy;
538 typedef UseInternalRangeChecker range_checking_policy;
539 typedef Trunc<long> rounding_policy;
540 };
541
542 template <>
543 struct numeric_cast_traits
544 <
545 short
546 , unsigned long
547 >
548 {
549 typedef def_overflow_handler overflow_policy;
550 typedef UseInternalRangeChecker range_checking_policy;
551 typedef Trunc<unsigned long> rounding_policy;
552 };
553
554 template <>
555 struct numeric_cast_traits
556 <
557 short
558 , float
559 >
560 {
561 typedef def_overflow_handler overflow_policy;
562 typedef UseInternalRangeChecker range_checking_policy;
563 typedef Trunc<float> rounding_policy;
564 };
565
566 template <>
567 struct numeric_cast_traits
568 <
569 short
570 , double
571 >
572 {
573 typedef def_overflow_handler overflow_policy;
574 typedef UseInternalRangeChecker range_checking_policy;
575 typedef Trunc<double> rounding_policy;
576 };
577
578 template <>
579 struct numeric_cast_traits
580 <
581 short
582 , long double
583 >
584 {
585 typedef def_overflow_handler overflow_policy;
586 typedef UseInternalRangeChecker range_checking_policy;
587 typedef Trunc<long double> rounding_policy;
588 };
589
590 template <>
591 struct numeric_cast_traits
592 <
593 unsigned short
594 , char
595 >
596 {
597 typedef def_overflow_handler overflow_policy;
598 typedef UseInternalRangeChecker range_checking_policy;
599 typedef Trunc<char> rounding_policy;
600 };
601
602 template <>
603 struct numeric_cast_traits
604 <
605 unsigned short
606 , signed char
607 >
608 {
609 typedef def_overflow_handler overflow_policy;
610 typedef UseInternalRangeChecker range_checking_policy;
611 typedef Trunc<signed char> rounding_policy;
612 };
613
614 template <>
615 struct numeric_cast_traits
616 <
617 unsigned short
618 , unsigned char
619 >
620 {
621 typedef def_overflow_handler overflow_policy;
622 typedef UseInternalRangeChecker range_checking_policy;
623 typedef Trunc<unsigned char> rounding_policy;
624 };
625
626 template <>
627 struct numeric_cast_traits
628 <
629 unsigned short
630 , short
631 >
632 {
633 typedef def_overflow_handler overflow_policy;
634 typedef UseInternalRangeChecker range_checking_policy;
635 typedef Trunc<short> rounding_policy;
636 };
637
638 template <>
639 struct numeric_cast_traits
640 <
641 unsigned short
642 , unsigned short
643 >
644 {
645 typedef def_overflow_handler overflow_policy;
646 typedef UseInternalRangeChecker range_checking_policy;
647 typedef Trunc<unsigned short> rounding_policy;
648 };
649
650 template <>
651 struct numeric_cast_traits
652 <
653 unsigned short
654 , int
655 >
656 {
657 typedef def_overflow_handler overflow_policy;
658 typedef UseInternalRangeChecker range_checking_policy;
659 typedef Trunc<int> rounding_policy;
660 };
661
662 template <>
663 struct numeric_cast_traits
664 <
665 unsigned short
666 , unsigned int
667 >
668 {
669 typedef def_overflow_handler overflow_policy;
670 typedef UseInternalRangeChecker range_checking_policy;
671 typedef Trunc<unsigned int> rounding_policy;
672 };
673
674 template <>
675 struct numeric_cast_traits
676 <
677 unsigned short
678 , long
679 >
680 {
681 typedef def_overflow_handler overflow_policy;
682 typedef UseInternalRangeChecker range_checking_policy;
683 typedef Trunc<long> rounding_policy;
684 };
685
686 template <>
687 struct numeric_cast_traits
688 <
689 unsigned short
690 , unsigned long
691 >
692 {
693 typedef def_overflow_handler overflow_policy;
694 typedef UseInternalRangeChecker range_checking_policy;
695 typedef Trunc<unsigned long> rounding_policy;
696 };
697
698 template <>
699 struct numeric_cast_traits
700 <
701 unsigned short
702 , float
703 >
704 {
705 typedef def_overflow_handler overflow_policy;
706 typedef UseInternalRangeChecker range_checking_policy;
707 typedef Trunc<float> rounding_policy;
708 };
709
710 template <>
711 struct numeric_cast_traits
712 <
713 unsigned short
714 , double
715 >
716 {
717 typedef def_overflow_handler overflow_policy;
718 typedef UseInternalRangeChecker range_checking_policy;
719 typedef Trunc<double> rounding_policy;
720 };
721
722 template <>
723 struct numeric_cast_traits
724 <
725 unsigned short
726 , long double
727 >
728 {
729 typedef def_overflow_handler overflow_policy;
730 typedef UseInternalRangeChecker range_checking_policy;
731 typedef Trunc<long double> rounding_policy;
732 };
733
734 template <>
735 struct numeric_cast_traits
736 <
737 int
738 , char
739 >
740 {
741 typedef def_overflow_handler overflow_policy;
742 typedef UseInternalRangeChecker range_checking_policy;
743 typedef Trunc<char> rounding_policy;
744 };
745
746 template <>
747 struct numeric_cast_traits
748 <
749 int
750 , signed char
751 >
752 {
753 typedef def_overflow_handler overflow_policy;
754 typedef UseInternalRangeChecker range_checking_policy;
755 typedef Trunc<signed char> rounding_policy;
756 };
757
758 template <>
759 struct numeric_cast_traits
760 <
761 int
762 , unsigned char
763 >
764 {
765 typedef def_overflow_handler overflow_policy;
766 typedef UseInternalRangeChecker range_checking_policy;
767 typedef Trunc<unsigned char> rounding_policy;
768 };
769
770 template <>
771 struct numeric_cast_traits
772 <
773 int
774 , short
775 >
776 {
777 typedef def_overflow_handler overflow_policy;
778 typedef UseInternalRangeChecker range_checking_policy;
779 typedef Trunc<short> rounding_policy;
780 };
781
782 template <>
783 struct numeric_cast_traits
784 <
785 int
786 , unsigned short
787 >
788 {
789 typedef def_overflow_handler overflow_policy;
790 typedef UseInternalRangeChecker range_checking_policy;
791 typedef Trunc<unsigned short> rounding_policy;
792 };
793
794 template <>
795 struct numeric_cast_traits
796 <
797 int
798 , int
799 >
800 {
801 typedef def_overflow_handler overflow_policy;
802 typedef UseInternalRangeChecker range_checking_policy;
803 typedef Trunc<int> rounding_policy;
804 };
805
806 template <>
807 struct numeric_cast_traits
808 <
809 int
810 , unsigned int
811 >
812 {
813 typedef def_overflow_handler overflow_policy;
814 typedef UseInternalRangeChecker range_checking_policy;
815 typedef Trunc<unsigned int> rounding_policy;
816 };
817
818 template <>
819 struct numeric_cast_traits
820 <
821 int
822 , long
823 >
824 {
825 typedef def_overflow_handler overflow_policy;
826 typedef UseInternalRangeChecker range_checking_policy;
827 typedef Trunc<long> rounding_policy;
828 };
829
830 template <>
831 struct numeric_cast_traits
832 <
833 int
834 , unsigned long
835 >
836 {
837 typedef def_overflow_handler overflow_policy;
838 typedef UseInternalRangeChecker range_checking_policy;
839 typedef Trunc<unsigned long> rounding_policy;
840 };
841
842 template <>
843 struct numeric_cast_traits
844 <
845 int
846 , float
847 >
848 {
849 typedef def_overflow_handler overflow_policy;
850 typedef UseInternalRangeChecker range_checking_policy;
851 typedef Trunc<float> rounding_policy;
852 };
853
854 template <>
855 struct numeric_cast_traits
856 <
857 int
858 , double
859 >
860 {
861 typedef def_overflow_handler overflow_policy;
862 typedef UseInternalRangeChecker range_checking_policy;
863 typedef Trunc<double> rounding_policy;
864 };
865
866 template <>
867 struct numeric_cast_traits
868 <
869 int
870 , long double
871 >
872 {
873 typedef def_overflow_handler overflow_policy;
874 typedef UseInternalRangeChecker range_checking_policy;
875 typedef Trunc<long double> rounding_policy;
876 };
877
878 template <>
879 struct numeric_cast_traits
880 <
881 unsigned int
882 , char
883 >
884 {
885 typedef def_overflow_handler overflow_policy;
886 typedef UseInternalRangeChecker range_checking_policy;
887 typedef Trunc<char> rounding_policy;
888 };
889
890 template <>
891 struct numeric_cast_traits
892 <
893 unsigned int
894 , signed char
895 >
896 {
897 typedef def_overflow_handler overflow_policy;
898 typedef UseInternalRangeChecker range_checking_policy;
899 typedef Trunc<signed char> rounding_policy;
900 };
901
902 template <>
903 struct numeric_cast_traits
904 <
905 unsigned int
906 , unsigned char
907 >
908 {
909 typedef def_overflow_handler overflow_policy;
910 typedef UseInternalRangeChecker range_checking_policy;
911 typedef Trunc<unsigned char> rounding_policy;
912 };
913
914 template <>
915 struct numeric_cast_traits
916 <
917 unsigned int
918 , short
919 >
920 {
921 typedef def_overflow_handler overflow_policy;
922 typedef UseInternalRangeChecker range_checking_policy;
923 typedef Trunc<short> rounding_policy;
924 };
925
926 template <>
927 struct numeric_cast_traits
928 <
929 unsigned int
930 , unsigned short
931 >
932 {
933 typedef def_overflow_handler overflow_policy;
934 typedef UseInternalRangeChecker range_checking_policy;
935 typedef Trunc<unsigned short> rounding_policy;
936 };
937
938 template <>
939 struct numeric_cast_traits
940 <
941 unsigned int
942 , int
943 >
944 {
945 typedef def_overflow_handler overflow_policy;
946 typedef UseInternalRangeChecker range_checking_policy;
947 typedef Trunc<int> rounding_policy;
948 };
949
950 template <>
951 struct numeric_cast_traits
952 <
953 unsigned int
954 , unsigned int
955 >
956 {
957 typedef def_overflow_handler overflow_policy;
958 typedef UseInternalRangeChecker range_checking_policy;
959 typedef Trunc<unsigned int> rounding_policy;
960 };
961
962 template <>
963 struct numeric_cast_traits
964 <
965 unsigned int
966 , long
967 >
968 {
969 typedef def_overflow_handler overflow_policy;
970 typedef UseInternalRangeChecker range_checking_policy;
971 typedef Trunc<long> rounding_policy;
972 };
973
974 template <>
975 struct numeric_cast_traits
976 <
977 unsigned int
978 , unsigned long
979 >
980 {
981 typedef def_overflow_handler overflow_policy;
982 typedef UseInternalRangeChecker range_checking_policy;
983 typedef Trunc<unsigned long> rounding_policy;
984 };
985
986 template <>
987 struct numeric_cast_traits
988 <
989 unsigned int
990 , float
991 >
992 {
993 typedef def_overflow_handler overflow_policy;
994 typedef UseInternalRangeChecker range_checking_policy;
995 typedef Trunc<float> rounding_policy;
996 };
997
998 template <>
999 struct numeric_cast_traits
1000 <
1001 unsigned int
1002 , double
1003 >
1004 {
1005 typedef def_overflow_handler overflow_policy;
1006 typedef UseInternalRangeChecker range_checking_policy;
1007 typedef Trunc<double> rounding_policy;
1008 };
1009
1010 template <>
1011 struct numeric_cast_traits
1012 <
1013 unsigned int
1014 , long double
1015 >
1016 {
1017 typedef def_overflow_handler overflow_policy;
1018 typedef UseInternalRangeChecker range_checking_policy;
1019 typedef Trunc<long double> rounding_policy;
1020 };
1021
1022 template <>
1023 struct numeric_cast_traits
1024 <
1025 long
1026 , char
1027 >
1028 {
1029 typedef def_overflow_handler overflow_policy;
1030 typedef UseInternalRangeChecker range_checking_policy;
1031 typedef Trunc<char> rounding_policy;
1032 };
1033
1034 template <>
1035 struct numeric_cast_traits
1036 <
1037 long
1038 , signed char
1039 >
1040 {
1041 typedef def_overflow_handler overflow_policy;
1042 typedef UseInternalRangeChecker range_checking_policy;
1043 typedef Trunc<signed char> rounding_policy;
1044 };
1045
1046 template <>
1047 struct numeric_cast_traits
1048 <
1049 long
1050 , unsigned char
1051 >
1052 {
1053 typedef def_overflow_handler overflow_policy;
1054 typedef UseInternalRangeChecker range_checking_policy;
1055 typedef Trunc<unsigned char> rounding_policy;
1056 };
1057
1058 template <>
1059 struct numeric_cast_traits
1060 <
1061 long
1062 , short
1063 >
1064 {
1065 typedef def_overflow_handler overflow_policy;
1066 typedef UseInternalRangeChecker range_checking_policy;
1067 typedef Trunc<short> rounding_policy;
1068 };
1069
1070 template <>
1071 struct numeric_cast_traits
1072 <
1073 long
1074 , unsigned short
1075 >
1076 {
1077 typedef def_overflow_handler overflow_policy;
1078 typedef UseInternalRangeChecker range_checking_policy;
1079 typedef Trunc<unsigned short> rounding_policy;
1080 };
1081
1082 template <>
1083 struct numeric_cast_traits
1084 <
1085 long
1086 , int
1087 >
1088 {
1089 typedef def_overflow_handler overflow_policy;
1090 typedef UseInternalRangeChecker range_checking_policy;
1091 typedef Trunc<int> rounding_policy;
1092 };
1093
1094 template <>
1095 struct numeric_cast_traits
1096 <
1097 long
1098 , unsigned int
1099 >
1100 {
1101 typedef def_overflow_handler overflow_policy;
1102 typedef UseInternalRangeChecker range_checking_policy;
1103 typedef Trunc<unsigned int> rounding_policy;
1104 };
1105
1106 template <>
1107 struct numeric_cast_traits
1108 <
1109 long
1110 , long
1111 >
1112 {
1113 typedef def_overflow_handler overflow_policy;
1114 typedef UseInternalRangeChecker range_checking_policy;
1115 typedef Trunc<long> rounding_policy;
1116 };
1117
1118 template <>
1119 struct numeric_cast_traits
1120 <
1121 long
1122 , unsigned long
1123 >
1124 {
1125 typedef def_overflow_handler overflow_policy;
1126 typedef UseInternalRangeChecker range_checking_policy;
1127 typedef Trunc<unsigned long> rounding_policy;
1128 };
1129
1130 template <>
1131 struct numeric_cast_traits
1132 <
1133 long
1134 , float
1135 >
1136 {
1137 typedef def_overflow_handler overflow_policy;
1138 typedef UseInternalRangeChecker range_checking_policy;
1139 typedef Trunc<float> rounding_policy;
1140 };
1141
1142 template <>
1143 struct numeric_cast_traits
1144 <
1145 long
1146 , double
1147 >
1148 {
1149 typedef def_overflow_handler overflow_policy;
1150 typedef UseInternalRangeChecker range_checking_policy;
1151 typedef Trunc<double> rounding_policy;
1152 };
1153
1154 template <>
1155 struct numeric_cast_traits
1156 <
1157 long
1158 , long double
1159 >
1160 {
1161 typedef def_overflow_handler overflow_policy;
1162 typedef UseInternalRangeChecker range_checking_policy;
1163 typedef Trunc<long double> rounding_policy;
1164 };
1165
1166 template <>
1167 struct numeric_cast_traits
1168 <
1169 unsigned long
1170 , char
1171 >
1172 {
1173 typedef def_overflow_handler overflow_policy;
1174 typedef UseInternalRangeChecker range_checking_policy;
1175 typedef Trunc<char> rounding_policy;
1176 };
1177
1178 template <>
1179 struct numeric_cast_traits
1180 <
1181 unsigned long
1182 , signed char
1183 >
1184 {
1185 typedef def_overflow_handler overflow_policy;
1186 typedef UseInternalRangeChecker range_checking_policy;
1187 typedef Trunc<signed char> rounding_policy;
1188 };
1189
1190 template <>
1191 struct numeric_cast_traits
1192 <
1193 unsigned long
1194 , unsigned char
1195 >
1196 {
1197 typedef def_overflow_handler overflow_policy;
1198 typedef UseInternalRangeChecker range_checking_policy;
1199 typedef Trunc<unsigned char> rounding_policy;
1200 };
1201
1202 template <>
1203 struct numeric_cast_traits
1204 <
1205 unsigned long
1206 , short
1207 >
1208 {
1209 typedef def_overflow_handler overflow_policy;
1210 typedef UseInternalRangeChecker range_checking_policy;
1211 typedef Trunc<short> rounding_policy;
1212 };
1213
1214 template <>
1215 struct numeric_cast_traits
1216 <
1217 unsigned long
1218 , unsigned short
1219 >
1220 {
1221 typedef def_overflow_handler overflow_policy;
1222 typedef UseInternalRangeChecker range_checking_policy;
1223 typedef Trunc<unsigned short> rounding_policy;
1224 };
1225
1226 template <>
1227 struct numeric_cast_traits
1228 <
1229 unsigned long
1230 , int
1231 >
1232 {
1233 typedef def_overflow_handler overflow_policy;
1234 typedef UseInternalRangeChecker range_checking_policy;
1235 typedef Trunc<int> rounding_policy;
1236 };
1237
1238 template <>
1239 struct numeric_cast_traits
1240 <
1241 unsigned long
1242 , unsigned int
1243 >
1244 {
1245 typedef def_overflow_handler overflow_policy;
1246 typedef UseInternalRangeChecker range_checking_policy;
1247 typedef Trunc<unsigned int> rounding_policy;
1248 };
1249
1250 template <>
1251 struct numeric_cast_traits
1252 <
1253 unsigned long
1254 , long
1255 >
1256 {
1257 typedef def_overflow_handler overflow_policy;
1258 typedef UseInternalRangeChecker range_checking_policy;
1259 typedef Trunc<long> rounding_policy;
1260 };
1261
1262 template <>
1263 struct numeric_cast_traits
1264 <
1265 unsigned long
1266 , unsigned long
1267 >
1268 {
1269 typedef def_overflow_handler overflow_policy;
1270 typedef UseInternalRangeChecker range_checking_policy;
1271 typedef Trunc<unsigned long> rounding_policy;
1272 };
1273
1274 template <>
1275 struct numeric_cast_traits
1276 <
1277 unsigned long
1278 , float
1279 >
1280 {
1281 typedef def_overflow_handler overflow_policy;
1282 typedef UseInternalRangeChecker range_checking_policy;
1283 typedef Trunc<float> rounding_policy;
1284 };
1285
1286 template <>
1287 struct numeric_cast_traits
1288 <
1289 unsigned long
1290 , double
1291 >
1292 {
1293 typedef def_overflow_handler overflow_policy;
1294 typedef UseInternalRangeChecker range_checking_policy;
1295 typedef Trunc<double> rounding_policy;
1296 };
1297
1298 template <>
1299 struct numeric_cast_traits
1300 <
1301 unsigned long
1302 , long double
1303 >
1304 {
1305 typedef def_overflow_handler overflow_policy;
1306 typedef UseInternalRangeChecker range_checking_policy;
1307 typedef Trunc<long double> rounding_policy;
1308 };
1309
1310 template <>
1311 struct numeric_cast_traits
1312 <
1313 float
1314 , char
1315 >
1316 {
1317 typedef def_overflow_handler overflow_policy;
1318 typedef UseInternalRangeChecker range_checking_policy;
1319 typedef Trunc<char> rounding_policy;
1320 };
1321
1322 template <>
1323 struct numeric_cast_traits
1324 <
1325 float
1326 , signed char
1327 >
1328 {
1329 typedef def_overflow_handler overflow_policy;
1330 typedef UseInternalRangeChecker range_checking_policy;
1331 typedef Trunc<signed char> rounding_policy;
1332 };
1333
1334 template <>
1335 struct numeric_cast_traits
1336 <
1337 float
1338 , unsigned char
1339 >
1340 {
1341 typedef def_overflow_handler overflow_policy;
1342 typedef UseInternalRangeChecker range_checking_policy;
1343 typedef Trunc<unsigned char> rounding_policy;
1344 };
1345
1346 template <>
1347 struct numeric_cast_traits
1348 <
1349 float
1350 , short
1351 >
1352 {
1353 typedef def_overflow_handler overflow_policy;
1354 typedef UseInternalRangeChecker range_checking_policy;
1355 typedef Trunc<short> rounding_policy;
1356 };
1357
1358 template <>
1359 struct numeric_cast_traits
1360 <
1361 float
1362 , unsigned short
1363 >
1364 {
1365 typedef def_overflow_handler overflow_policy;
1366 typedef UseInternalRangeChecker range_checking_policy;
1367 typedef Trunc<unsigned short> rounding_policy;
1368 };
1369
1370 template <>
1371 struct numeric_cast_traits
1372 <
1373 float
1374 , int
1375 >
1376 {
1377 typedef def_overflow_handler overflow_policy;
1378 typedef UseInternalRangeChecker range_checking_policy;
1379 typedef Trunc<int> rounding_policy;
1380 };
1381
1382 template <>
1383 struct numeric_cast_traits
1384 <
1385 float
1386 , unsigned int
1387 >
1388 {
1389 typedef def_overflow_handler overflow_policy;
1390 typedef UseInternalRangeChecker range_checking_policy;
1391 typedef Trunc<unsigned int> rounding_policy;
1392 };
1393
1394 template <>
1395 struct numeric_cast_traits
1396 <
1397 float
1398 , long
1399 >
1400 {
1401 typedef def_overflow_handler overflow_policy;
1402 typedef UseInternalRangeChecker range_checking_policy;
1403 typedef Trunc<long> rounding_policy;
1404 };
1405
1406 template <>
1407 struct numeric_cast_traits
1408 <
1409 float
1410 , unsigned long
1411 >
1412 {
1413 typedef def_overflow_handler overflow_policy;
1414 typedef UseInternalRangeChecker range_checking_policy;
1415 typedef Trunc<unsigned long> rounding_policy;
1416 };
1417
1418 template <>
1419 struct numeric_cast_traits
1420 <
1421 float
1422 , float
1423 >
1424 {
1425 typedef def_overflow_handler overflow_policy;
1426 typedef UseInternalRangeChecker range_checking_policy;
1427 typedef Trunc<float> rounding_policy;
1428 };
1429
1430 template <>
1431 struct numeric_cast_traits
1432 <
1433 float
1434 , double
1435 >
1436 {
1437 typedef def_overflow_handler overflow_policy;
1438 typedef UseInternalRangeChecker range_checking_policy;
1439 typedef Trunc<double> rounding_policy;
1440 };
1441
1442 template <>
1443 struct numeric_cast_traits
1444 <
1445 float
1446 , long double
1447 >
1448 {
1449 typedef def_overflow_handler overflow_policy;
1450 typedef UseInternalRangeChecker range_checking_policy;
1451 typedef Trunc<long double> rounding_policy;
1452 };
1453
1454 template <>
1455 struct numeric_cast_traits
1456 <
1457 double
1458 , char
1459 >
1460 {
1461 typedef def_overflow_handler overflow_policy;
1462 typedef UseInternalRangeChecker range_checking_policy;
1463 typedef Trunc<char> rounding_policy;
1464 };
1465
1466 template <>
1467 struct numeric_cast_traits
1468 <
1469 double
1470 , signed char
1471 >
1472 {
1473 typedef def_overflow_handler overflow_policy;
1474 typedef UseInternalRangeChecker range_checking_policy;
1475 typedef Trunc<signed char> rounding_policy;
1476 };
1477
1478 template <>
1479 struct numeric_cast_traits
1480 <
1481 double
1482 , unsigned char
1483 >
1484 {
1485 typedef def_overflow_handler overflow_policy;
1486 typedef UseInternalRangeChecker range_checking_policy;
1487 typedef Trunc<unsigned char> rounding_policy;
1488 };
1489
1490 template <>
1491 struct numeric_cast_traits
1492 <
1493 double
1494 , short
1495 >
1496 {
1497 typedef def_overflow_handler overflow_policy;
1498 typedef UseInternalRangeChecker range_checking_policy;
1499 typedef Trunc<short> rounding_policy;
1500 };
1501
1502 template <>
1503 struct numeric_cast_traits
1504 <
1505 double
1506 , unsigned short
1507 >
1508 {
1509 typedef def_overflow_handler overflow_policy;
1510 typedef UseInternalRangeChecker range_checking_policy;
1511 typedef Trunc<unsigned short> rounding_policy;
1512 };
1513
1514 template <>
1515 struct numeric_cast_traits
1516 <
1517 double
1518 , int
1519 >
1520 {
1521 typedef def_overflow_handler overflow_policy;
1522 typedef UseInternalRangeChecker range_checking_policy;
1523 typedef Trunc<int> rounding_policy;
1524 };
1525
1526 template <>
1527 struct numeric_cast_traits
1528 <
1529 double
1530 , unsigned int
1531 >
1532 {
1533 typedef def_overflow_handler overflow_policy;
1534 typedef UseInternalRangeChecker range_checking_policy;
1535 typedef Trunc<unsigned int> rounding_policy;
1536 };
1537
1538 template <>
1539 struct numeric_cast_traits
1540 <
1541 double
1542 , long
1543 >
1544 {
1545 typedef def_overflow_handler overflow_policy;
1546 typedef UseInternalRangeChecker range_checking_policy;
1547 typedef Trunc<long> rounding_policy;
1548 };
1549
1550 template <>
1551 struct numeric_cast_traits
1552 <
1553 double
1554 , unsigned long
1555 >
1556 {
1557 typedef def_overflow_handler overflow_policy;
1558 typedef UseInternalRangeChecker range_checking_policy;
1559 typedef Trunc<unsigned long> rounding_policy;
1560 };
1561
1562 template <>
1563 struct numeric_cast_traits
1564 <
1565 double
1566 , float
1567 >
1568 {
1569 typedef def_overflow_handler overflow_policy;
1570 typedef UseInternalRangeChecker range_checking_policy;
1571 typedef Trunc<float> rounding_policy;
1572 };
1573
1574 template <>
1575 struct numeric_cast_traits
1576 <
1577 double
1578 , double
1579 >
1580 {
1581 typedef def_overflow_handler overflow_policy;
1582 typedef UseInternalRangeChecker range_checking_policy;
1583 typedef Trunc<double> rounding_policy;
1584 };
1585
1586 template <>
1587 struct numeric_cast_traits
1588 <
1589 double
1590 , long double
1591 >
1592 {
1593 typedef def_overflow_handler overflow_policy;
1594 typedef UseInternalRangeChecker range_checking_policy;
1595 typedef Trunc<long double> rounding_policy;
1596 };
1597
1598 template <>
1599 struct numeric_cast_traits
1600 <
1601 long double
1602 , char
1603 >
1604 {
1605 typedef def_overflow_handler overflow_policy;
1606 typedef UseInternalRangeChecker range_checking_policy;
1607 typedef Trunc<char> rounding_policy;
1608 };
1609
1610 template <>
1611 struct numeric_cast_traits
1612 <
1613 long double
1614 , signed char
1615 >
1616 {
1617 typedef def_overflow_handler overflow_policy;
1618 typedef UseInternalRangeChecker range_checking_policy;
1619 typedef Trunc<signed char> rounding_policy;
1620 };
1621
1622 template <>
1623 struct numeric_cast_traits
1624 <
1625 long double
1626 , unsigned char
1627 >
1628 {
1629 typedef def_overflow_handler overflow_policy;
1630 typedef UseInternalRangeChecker range_checking_policy;
1631 typedef Trunc<unsigned char> rounding_policy;
1632 };
1633
1634 template <>
1635 struct numeric_cast_traits
1636 <
1637 long double
1638 , short
1639 >
1640 {
1641 typedef def_overflow_handler overflow_policy;
1642 typedef UseInternalRangeChecker range_checking_policy;
1643 typedef Trunc<short> rounding_policy;
1644 };
1645
1646 template <>
1647 struct numeric_cast_traits
1648 <
1649 long double
1650 , unsigned short
1651 >
1652 {
1653 typedef def_overflow_handler overflow_policy;
1654 typedef UseInternalRangeChecker range_checking_policy;
1655 typedef Trunc<unsigned short> rounding_policy;
1656 };
1657
1658 template <>
1659 struct numeric_cast_traits
1660 <
1661 long double
1662 , int
1663 >
1664 {
1665 typedef def_overflow_handler overflow_policy;
1666 typedef UseInternalRangeChecker range_checking_policy;
1667 typedef Trunc<int> rounding_policy;
1668 };
1669
1670 template <>
1671 struct numeric_cast_traits
1672 <
1673 long double
1674 , unsigned int
1675 >
1676 {
1677 typedef def_overflow_handler overflow_policy;
1678 typedef UseInternalRangeChecker range_checking_policy;
1679 typedef Trunc<unsigned int> rounding_policy;
1680 };
1681
1682 template <>
1683 struct numeric_cast_traits
1684 <
1685 long double
1686 , long
1687 >
1688 {
1689 typedef def_overflow_handler overflow_policy;
1690 typedef UseInternalRangeChecker range_checking_policy;
1691 typedef Trunc<long> rounding_policy;
1692 };
1693
1694 template <>
1695 struct numeric_cast_traits
1696 <
1697 long double
1698 , unsigned long
1699 >
1700 {
1701 typedef def_overflow_handler overflow_policy;
1702 typedef UseInternalRangeChecker range_checking_policy;
1703 typedef Trunc<unsigned long> rounding_policy;
1704 };
1705
1706 template <>
1707 struct numeric_cast_traits
1708 <
1709 long double
1710 , float
1711 >
1712 {
1713 typedef def_overflow_handler overflow_policy;
1714 typedef UseInternalRangeChecker range_checking_policy;
1715 typedef Trunc<float> rounding_policy;
1716 };
1717
1718 template <>
1719 struct numeric_cast_traits
1720 <
1721 long double
1722 , double
1723 >
1724 {
1725 typedef def_overflow_handler overflow_policy;
1726 typedef UseInternalRangeChecker range_checking_policy;
1727 typedef Trunc<double> rounding_policy;
1728 };
1729
1730 template <>
1731 struct numeric_cast_traits
1732 <
1733 long double
1734 , long double
1735 >
1736 {
1737 typedef def_overflow_handler overflow_policy;
1738 typedef UseInternalRangeChecker range_checking_policy;
1739 typedef Trunc<long double> rounding_policy;
1740 };
1741}}
1742

source code of include/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_common.hpp