ceph/src/boost/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_common.hpp

   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 }}