boost/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits.hpp

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