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 12 namespace 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