detail/preprocessed/numeric_cast_traits_common.hpp

0001 //
0002 //! Copyright (c) 2011-2012
0003 //! Brandon Kohn
0004 //
0005 //  Distributed under the Boost Software License, Version 1.0. (See
0006 //  accompanying file LICENSE_1_0.txt or copy at
0007 //  http://www.boost.org/LICENSE_1_0.txt)
0008 //
0009
0010
0011
0012 namespace boost { namespace numeric {
0013
0014     template <>
0015     struct numeric_cast_traits
0016         <
0017             char
0018           , char
0019         >
0020     {
0021         typedef def_overflow_handler overflow_policy;
0022         typedef UseInternalRangeChecker range_checking_policy;
0023         typedef Trunc<char> rounding_policy;
0024     };
0025
0026     template <>
0027     struct numeric_cast_traits
0028         <
0029             char
0030           , signed char
0031         >
0032     {
0033         typedef def_overflow_handler overflow_policy;
0034         typedef UseInternalRangeChecker range_checking_policy;
0035         typedef Trunc<signed char> rounding_policy;
0036     };
0037
0038     template <>
0039     struct numeric_cast_traits
0040         <
0041             char
0042           , unsigned char
0043         >
0044     {
0045         typedef def_overflow_handler overflow_policy;
0046         typedef UseInternalRangeChecker range_checking_policy;
0047         typedef Trunc<unsigned char> rounding_policy;
0048     };
0049
0050     template <>
0051     struct numeric_cast_traits
0052         <
0053             char
0054           , short
0055         >
0056     {
0057         typedef def_overflow_handler overflow_policy;
0058         typedef UseInternalRangeChecker range_checking_policy;
0059         typedef Trunc<short> rounding_policy;
0060     };
0061
0062     template <>
0063     struct numeric_cast_traits
0064         <
0065             char
0066           , unsigned short
0067         >
0068     {
0069         typedef def_overflow_handler overflow_policy;
0070         typedef UseInternalRangeChecker range_checking_policy;
0071         typedef Trunc<unsigned short> rounding_policy;
0072     };
0073
0074     template <>
0075     struct numeric_cast_traits
0076         <
0077             char
0078           , int
0079         >
0080     {
0081         typedef def_overflow_handler overflow_policy;
0082         typedef UseInternalRangeChecker range_checking_policy;
0083         typedef Trunc<int> rounding_policy;
0084     };
0085
0086     template <>
0087     struct numeric_cast_traits
0088         <
0089             char
0090           , unsigned int
0091         >
0092     {
0093         typedef def_overflow_handler overflow_policy;
0094         typedef UseInternalRangeChecker range_checking_policy;
0095         typedef Trunc<unsigned int> rounding_policy;
0096     };
0097
0098     template <>
0099     struct numeric_cast_traits
0100         <
0101             char
0102           , long
0103         >
0104     {
0105         typedef def_overflow_handler overflow_policy;
0106         typedef UseInternalRangeChecker range_checking_policy;
0107         typedef Trunc<long> rounding_policy;
0108     };
0109
0110     template <>
0111     struct numeric_cast_traits
0112         <
0113             char
0114           , unsigned long
0115         >
0116     {
0117         typedef def_overflow_handler overflow_policy;
0118         typedef UseInternalRangeChecker range_checking_policy;
0119         typedef Trunc<unsigned long> rounding_policy;
0120     };
0121
0122     template <>
0123     struct numeric_cast_traits
0124         <
0125             char
0126           , float
0127         >
0128     {
0129         typedef def_overflow_handler overflow_policy;
0130         typedef UseInternalRangeChecker range_checking_policy;
0131         typedef Trunc<float> rounding_policy;
0132     };
0133
0134     template <>
0135     struct numeric_cast_traits
0136         <
0137             char
0138           , double
0139         >
0140     {
0141         typedef def_overflow_handler overflow_policy;
0142         typedef UseInternalRangeChecker range_checking_policy;
0143         typedef Trunc<double> rounding_policy;
0144     };
0145
0146     template <>
0147     struct numeric_cast_traits
0148         <
0149             char
0150           , long double
0151         >
0152     {
0153         typedef def_overflow_handler overflow_policy;
0154         typedef UseInternalRangeChecker range_checking_policy;
0155         typedef Trunc<long double> rounding_policy;
0156     };
0157
0158     template <>
0159     struct numeric_cast_traits
0160         <
0161             signed char
0162           , char
0163         >
0164     {
0165         typedef def_overflow_handler overflow_policy;
0166         typedef UseInternalRangeChecker range_checking_policy;
0167         typedef Trunc<char> rounding_policy;
0168     };
0169
0170     template <>
0171     struct numeric_cast_traits
0172         <
0173             signed char
0174           , signed char
0175         >
0176     {
0177         typedef def_overflow_handler overflow_policy;
0178         typedef UseInternalRangeChecker range_checking_policy;
0179         typedef Trunc<signed char> rounding_policy;
0180     };
0181
0182     template <>
0183     struct numeric_cast_traits
0184         <
0185             signed char
0186           , unsigned char
0187         >
0188     {
0189         typedef def_overflow_handler overflow_policy;
0190         typedef UseInternalRangeChecker range_checking_policy;
0191         typedef Trunc<unsigned char> rounding_policy;
0192     };
0193
0194     template <>
0195     struct numeric_cast_traits
0196         <
0197             signed char
0198           , short
0199         >
0200     {
0201         typedef def_overflow_handler overflow_policy;
0202         typedef UseInternalRangeChecker range_checking_policy;
0203         typedef Trunc<short> rounding_policy;
0204     };
0205
0206     template <>
0207     struct numeric_cast_traits
0208         <
0209             signed char
0210           , unsigned short
0211         >
0212     {
0213         typedef def_overflow_handler overflow_policy;
0214         typedef UseInternalRangeChecker range_checking_policy;
0215         typedef Trunc<unsigned short> rounding_policy;
0216     };
0217
0218     template <>
0219     struct numeric_cast_traits
0220         <
0221             signed char
0222           , int
0223         >
0224     {
0225         typedef def_overflow_handler overflow_policy;
0226         typedef UseInternalRangeChecker range_checking_policy;
0227         typedef Trunc<int> rounding_policy;
0228     };
0229
0230     template <>
0231     struct numeric_cast_traits
0232         <
0233             signed char
0234           , unsigned int
0235         >
0236     {
0237         typedef def_overflow_handler overflow_policy;
0238         typedef UseInternalRangeChecker range_checking_policy;
0239         typedef Trunc<unsigned int> rounding_policy;
0240     };
0241
0242     template <>
0243     struct numeric_cast_traits
0244         <
0245             signed char
0246           , long
0247         >
0248     {
0249         typedef def_overflow_handler overflow_policy;
0250         typedef UseInternalRangeChecker range_checking_policy;
0251         typedef Trunc<long> rounding_policy;
0252     };
0253
0254     template <>
0255     struct numeric_cast_traits
0256         <
0257             signed char
0258           , unsigned long
0259         >
0260     {
0261         typedef def_overflow_handler overflow_policy;
0262         typedef UseInternalRangeChecker range_checking_policy;
0263         typedef Trunc<unsigned long> rounding_policy;
0264     };
0265
0266     template <>
0267     struct numeric_cast_traits
0268         <
0269             signed char
0270           , float
0271         >
0272     {
0273         typedef def_overflow_handler overflow_policy;
0274         typedef UseInternalRangeChecker range_checking_policy;
0275         typedef Trunc<float> rounding_policy;
0276     };
0277
0278     template <>
0279     struct numeric_cast_traits
0280         <
0281             signed char
0282           , double
0283         >
0284     {
0285         typedef def_overflow_handler overflow_policy;
0286         typedef UseInternalRangeChecker range_checking_policy;
0287         typedef Trunc<double> rounding_policy;
0288     };
0289
0290     template <>
0291     struct numeric_cast_traits
0292         <
0293             signed char
0294           , long double
0295         >
0296     {
0297         typedef def_overflow_handler overflow_policy;
0298         typedef UseInternalRangeChecker range_checking_policy;
0299         typedef Trunc<long double> rounding_policy;
0300     };
0301
0302     template <>
0303     struct numeric_cast_traits
0304         <
0305             unsigned char
0306           , char
0307         >
0308     {
0309         typedef def_overflow_handler overflow_policy;
0310         typedef UseInternalRangeChecker range_checking_policy;
0311         typedef Trunc<char> rounding_policy;
0312     };
0313
0314     template <>
0315     struct numeric_cast_traits
0316         <
0317             unsigned char
0318           , signed char
0319         >
0320     {
0321         typedef def_overflow_handler overflow_policy;
0322         typedef UseInternalRangeChecker range_checking_policy;
0323         typedef Trunc<signed char> rounding_policy;
0324     };
0325
0326     template <>
0327     struct numeric_cast_traits
0328         <
0329             unsigned char
0330           , unsigned char
0331         >
0332     {
0333         typedef def_overflow_handler overflow_policy;
0334         typedef UseInternalRangeChecker range_checking_policy;
0335         typedef Trunc<unsigned char> rounding_policy;
0336     };
0337
0338     template <>
0339     struct numeric_cast_traits
0340         <
0341             unsigned char
0342           , short
0343         >
0344     {
0345         typedef def_overflow_handler overflow_policy;
0346         typedef UseInternalRangeChecker range_checking_policy;
0347         typedef Trunc<short> rounding_policy;
0348     };
0349
0350     template <>
0351     struct numeric_cast_traits
0352         <
0353             unsigned char
0354           , unsigned short
0355         >
0356     {
0357         typedef def_overflow_handler overflow_policy;
0358         typedef UseInternalRangeChecker range_checking_policy;
0359         typedef Trunc<unsigned short> rounding_policy;
0360     };
0361
0362     template <>
0363     struct numeric_cast_traits
0364         <
0365             unsigned char
0366           , int
0367         >
0368     {
0369         typedef def_overflow_handler overflow_policy;
0370         typedef UseInternalRangeChecker range_checking_policy;
0371         typedef Trunc<int> rounding_policy;
0372     };
0373
0374     template <>
0375     struct numeric_cast_traits
0376         <
0377             unsigned char
0378           , unsigned int
0379         >
0380     {
0381         typedef def_overflow_handler overflow_policy;
0382         typedef UseInternalRangeChecker range_checking_policy;
0383         typedef Trunc<unsigned int> rounding_policy;
0384     };
0385
0386     template <>
0387     struct numeric_cast_traits
0388         <
0389             unsigned char
0390           , long
0391         >
0392     {
0393         typedef def_overflow_handler overflow_policy;
0394         typedef UseInternalRangeChecker range_checking_policy;
0395         typedef Trunc<long> rounding_policy;
0396     };
0397
0398     template <>
0399     struct numeric_cast_traits
0400         <
0401             unsigned char
0402           , unsigned long
0403         >
0404     {
0405         typedef def_overflow_handler overflow_policy;
0406         typedef UseInternalRangeChecker range_checking_policy;
0407         typedef Trunc<unsigned long> rounding_policy;
0408     };
0409
0410     template <>
0411     struct numeric_cast_traits
0412         <
0413             unsigned char
0414           , float
0415         >
0416     {
0417         typedef def_overflow_handler overflow_policy;
0418         typedef UseInternalRangeChecker range_checking_policy;
0419         typedef Trunc<float> rounding_policy;
0420     };
0421
0422     template <>
0423     struct numeric_cast_traits
0424         <
0425             unsigned char
0426           , double
0427         >
0428     {
0429         typedef def_overflow_handler overflow_policy;
0430         typedef UseInternalRangeChecker range_checking_policy;
0431         typedef Trunc<double> rounding_policy;
0432     };
0433
0434     template <>
0435     struct numeric_cast_traits
0436         <
0437             unsigned char
0438           , long double
0439         >
0440     {
0441         typedef def_overflow_handler overflow_policy;
0442         typedef UseInternalRangeChecker range_checking_policy;
0443         typedef Trunc<long double> rounding_policy;
0444     };
0445
0446     template <>
0447     struct numeric_cast_traits
0448         <
0449             short
0450           , char
0451         >
0452     {
0453         typedef def_overflow_handler overflow_policy;
0454         typedef UseInternalRangeChecker range_checking_policy;
0455         typedef Trunc<char> rounding_policy;
0456     };
0457
0458     template <>
0459     struct numeric_cast_traits
0460         <
0461             short
0462           , signed char
0463         >
0464     {
0465         typedef def_overflow_handler overflow_policy;
0466         typedef UseInternalRangeChecker range_checking_policy;
0467         typedef Trunc<signed char> rounding_policy;
0468     };
0469
0470     template <>
0471     struct numeric_cast_traits
0472         <
0473             short
0474           , unsigned char
0475         >
0476     {
0477         typedef def_overflow_handler overflow_policy;
0478         typedef UseInternalRangeChecker range_checking_policy;
0479         typedef Trunc<unsigned char> rounding_policy;
0480     };
0481
0482     template <>
0483     struct numeric_cast_traits
0484         <
0485             short
0486           , short
0487         >
0488     {
0489         typedef def_overflow_handler overflow_policy;
0490         typedef UseInternalRangeChecker range_checking_policy;
0491         typedef Trunc<short> rounding_policy;
0492     };
0493
0494     template <>
0495     struct numeric_cast_traits
0496         <
0497             short
0498           , unsigned short
0499         >
0500     {
0501         typedef def_overflow_handler overflow_policy;
0502         typedef UseInternalRangeChecker range_checking_policy;
0503         typedef Trunc<unsigned short> rounding_policy;
0504     };
0505
0506     template <>
0507     struct numeric_cast_traits
0508         <
0509             short
0510           , int
0511         >
0512     {
0513         typedef def_overflow_handler overflow_policy;
0514         typedef UseInternalRangeChecker range_checking_policy;
0515         typedef Trunc<int> rounding_policy;
0516     };
0517
0518     template <>
0519     struct numeric_cast_traits
0520         <
0521             short
0522           , unsigned int
0523         >
0524     {
0525         typedef def_overflow_handler overflow_policy;
0526         typedef UseInternalRangeChecker range_checking_policy;
0527         typedef Trunc<unsigned int> rounding_policy;
0528     };
0529
0530     template <>
0531     struct numeric_cast_traits
0532         <
0533             short
0534           , long
0535         >
0536     {
0537         typedef def_overflow_handler overflow_policy;
0538         typedef UseInternalRangeChecker range_checking_policy;
0539         typedef Trunc<long> rounding_policy;
0540     };
0541
0542     template <>
0543     struct numeric_cast_traits
0544         <
0545             short
0546           , unsigned long
0547         >
0548     {
0549         typedef def_overflow_handler overflow_policy;
0550         typedef UseInternalRangeChecker range_checking_policy;
0551         typedef Trunc<unsigned long> rounding_policy;
0552     };
0553
0554     template <>
0555     struct numeric_cast_traits
0556         <
0557             short
0558           , float
0559         >
0560     {
0561         typedef def_overflow_handler overflow_policy;
0562         typedef UseInternalRangeChecker range_checking_policy;
0563         typedef Trunc<float> rounding_policy;
0564     };
0565
0566     template <>
0567     struct numeric_cast_traits
0568         <
0569             short
0570           , double
0571         >
0572     {
0573         typedef def_overflow_handler overflow_policy;
0574         typedef UseInternalRangeChecker range_checking_policy;
0575         typedef Trunc<double> rounding_policy;
0576     };
0577
0578     template <>
0579     struct numeric_cast_traits
0580         <
0581             short
0582           , long double
0583         >
0584     {
0585         typedef def_overflow_handler overflow_policy;
0586         typedef UseInternalRangeChecker range_checking_policy;
0587         typedef Trunc<long double> rounding_policy;
0588     };
0589
0590     template <>
0591     struct numeric_cast_traits
0592         <
0593             unsigned short
0594           , char
0595         >
0596     {
0597         typedef def_overflow_handler overflow_policy;
0598         typedef UseInternalRangeChecker range_checking_policy;
0599         typedef Trunc<char> rounding_policy;
0600     };
0601
0602     template <>
0603     struct numeric_cast_traits
0604         <
0605             unsigned short
0606           , signed char
0607         >
0608     {
0609         typedef def_overflow_handler overflow_policy;
0610         typedef UseInternalRangeChecker range_checking_policy;
0611         typedef Trunc<signed char> rounding_policy;
0612     };
0613
0614     template <>
0615     struct numeric_cast_traits
0616         <
0617             unsigned short
0618           , unsigned char
0619         >
0620     {
0621         typedef def_overflow_handler overflow_policy;
0622         typedef UseInternalRangeChecker range_checking_policy;
0623         typedef Trunc<unsigned char> rounding_policy;
0624     };
0625
0626     template <>
0627     struct numeric_cast_traits
0628         <
0629             unsigned short
0630           , short
0631         >
0632     {
0633         typedef def_overflow_handler overflow_policy;
0634         typedef UseInternalRangeChecker range_checking_policy;
0635         typedef Trunc<short> rounding_policy;
0636     };
0637
0638     template <>
0639     struct numeric_cast_traits
0640         <
0641             unsigned short
0642           , unsigned short
0643         >
0644     {
0645         typedef def_overflow_handler overflow_policy;
0646         typedef UseInternalRangeChecker range_checking_policy;
0647         typedef Trunc<unsigned short> rounding_policy;
0648     };
0649
0650     template <>
0651     struct numeric_cast_traits
0652         <
0653             unsigned short
0654           , int
0655         >
0656     {
0657         typedef def_overflow_handler overflow_policy;
0658         typedef UseInternalRangeChecker range_checking_policy;
0659         typedef Trunc<int> rounding_policy;
0660     };
0661
0662     template <>
0663     struct numeric_cast_traits
0664         <
0665             unsigned short
0666           , unsigned int
0667         >
0668     {
0669         typedef def_overflow_handler overflow_policy;
0670         typedef UseInternalRangeChecker range_checking_policy;
0671         typedef Trunc<unsigned int> rounding_policy;
0672     };
0673
0674     template <>
0675     struct numeric_cast_traits
0676         <
0677             unsigned short
0678           , long
0679         >
0680     {
0681         typedef def_overflow_handler overflow_policy;
0682         typedef UseInternalRangeChecker range_checking_policy;
0683         typedef Trunc<long> rounding_policy;
0684     };
0685
0686     template <>
0687     struct numeric_cast_traits
0688         <
0689             unsigned short
0690           , unsigned long
0691         >
0692     {
0693         typedef def_overflow_handler overflow_policy;
0694         typedef UseInternalRangeChecker range_checking_policy;
0695         typedef Trunc<unsigned long> rounding_policy;
0696     };
0697
0698     template <>
0699     struct numeric_cast_traits
0700         <
0701             unsigned short
0702           , float
0703         >
0704     {
0705         typedef def_overflow_handler overflow_policy;
0706         typedef UseInternalRangeChecker range_checking_policy;
0707         typedef Trunc<float> rounding_policy;
0708     };
0709
0710     template <>
0711     struct numeric_cast_traits
0712         <
0713             unsigned short
0714           , double
0715         >
0716     {
0717         typedef def_overflow_handler overflow_policy;
0718         typedef UseInternalRangeChecker range_checking_policy;
0719         typedef Trunc<double> rounding_policy;
0720     };
0721
0722     template <>
0723     struct numeric_cast_traits
0724         <
0725             unsigned short
0726           , long double
0727         >
0728     {
0729         typedef def_overflow_handler overflow_policy;
0730         typedef UseInternalRangeChecker range_checking_policy;
0731         typedef Trunc<long double> rounding_policy;
0732     };
0733
0734     template <>
0735     struct numeric_cast_traits
0736         <
0737             int
0738           , char
0739         >
0740     {
0741         typedef def_overflow_handler overflow_policy;
0742         typedef UseInternalRangeChecker range_checking_policy;
0743         typedef Trunc<char> rounding_policy;
0744     };
0745
0746     template <>
0747     struct numeric_cast_traits
0748         <
0749             int
0750           , signed char
0751         >
0752     {
0753         typedef def_overflow_handler overflow_policy;
0754         typedef UseInternalRangeChecker range_checking_policy;
0755         typedef Trunc<signed char> rounding_policy;
0756     };
0757
0758     template <>
0759     struct numeric_cast_traits
0760         <
0761             int
0762           , unsigned char
0763         >
0764     {
0765         typedef def_overflow_handler overflow_policy;
0766         typedef UseInternalRangeChecker range_checking_policy;
0767         typedef Trunc<unsigned char> rounding_policy;
0768     };
0769
0770     template <>
0771     struct numeric_cast_traits
0772         <
0773             int
0774           , short
0775         >
0776     {
0777         typedef def_overflow_handler overflow_policy;
0778         typedef UseInternalRangeChecker range_checking_policy;
0779         typedef Trunc<short> rounding_policy;
0780     };
0781
0782     template <>
0783     struct numeric_cast_traits
0784         <
0785             int
0786           , unsigned short
0787         >
0788     {
0789         typedef def_overflow_handler overflow_policy;
0790         typedef UseInternalRangeChecker range_checking_policy;
0791         typedef Trunc<unsigned short> rounding_policy;
0792     };
0793
0794     template <>
0795     struct numeric_cast_traits
0796         <
0797             int
0798           , int
0799         >
0800     {
0801         typedef def_overflow_handler overflow_policy;
0802         typedef UseInternalRangeChecker range_checking_policy;
0803         typedef Trunc<int> rounding_policy;
0804     };
0805
0806     template <>
0807     struct numeric_cast_traits
0808         <
0809             int
0810           , unsigned int
0811         >
0812     {
0813         typedef def_overflow_handler overflow_policy;
0814         typedef UseInternalRangeChecker range_checking_policy;
0815         typedef Trunc<unsigned int> rounding_policy;
0816     };
0817
0818     template <>
0819     struct numeric_cast_traits
0820         <
0821             int
0822           , long
0823         >
0824     {
0825         typedef def_overflow_handler overflow_policy;
0826         typedef UseInternalRangeChecker range_checking_policy;
0827         typedef Trunc<long> rounding_policy;
0828     };
0829
0830     template <>
0831     struct numeric_cast_traits
0832         <
0833             int
0834           , unsigned long
0835         >
0836     {
0837         typedef def_overflow_handler overflow_policy;
0838         typedef UseInternalRangeChecker range_checking_policy;
0839         typedef Trunc<unsigned long> rounding_policy;
0840     };
0841
0842     template <>
0843     struct numeric_cast_traits
0844         <
0845             int
0846           , float
0847         >
0848     {
0849         typedef def_overflow_handler overflow_policy;
0850         typedef UseInternalRangeChecker range_checking_policy;
0851         typedef Trunc<float> rounding_policy;
0852     };
0853
0854     template <>
0855     struct numeric_cast_traits
0856         <
0857             int
0858           , double
0859         >
0860     {
0861         typedef def_overflow_handler overflow_policy;
0862         typedef UseInternalRangeChecker range_checking_policy;
0863         typedef Trunc<double> rounding_policy;
0864     };
0865
0866     template <>
0867     struct numeric_cast_traits
0868         <
0869             int
0870           , long double
0871         >
0872     {
0873         typedef def_overflow_handler overflow_policy;
0874         typedef UseInternalRangeChecker range_checking_policy;
0875         typedef Trunc<long double> rounding_policy;
0876     };
0877
0878     template <>
0879     struct numeric_cast_traits
0880         <
0881             unsigned int
0882           , char
0883         >
0884     {
0885         typedef def_overflow_handler overflow_policy;
0886         typedef UseInternalRangeChecker range_checking_policy;
0887         typedef Trunc<char> rounding_policy;
0888     };
0889
0890     template <>
0891     struct numeric_cast_traits
0892         <
0893             unsigned int
0894           , signed char
0895         >
0896     {
0897         typedef def_overflow_handler overflow_policy;
0898         typedef UseInternalRangeChecker range_checking_policy;
0899         typedef Trunc<signed char> rounding_policy;
0900     };
0901
0902     template <>
0903     struct numeric_cast_traits
0904         <
0905             unsigned int
0906           , unsigned char
0907         >
0908     {
0909         typedef def_overflow_handler overflow_policy;
0910         typedef UseInternalRangeChecker range_checking_policy;
0911         typedef Trunc<unsigned char> rounding_policy;
0912     };
0913
0914     template <>
0915     struct numeric_cast_traits
0916         <
0917             unsigned int
0918           , short
0919         >
0920     {
0921         typedef def_overflow_handler overflow_policy;
0922         typedef UseInternalRangeChecker range_checking_policy;
0923         typedef Trunc<short> rounding_policy;
0924     };
0925
0926     template <>
0927     struct numeric_cast_traits
0928         <
0929             unsigned int
0930           , unsigned short
0931         >
0932     {
0933         typedef def_overflow_handler overflow_policy;
0934         typedef UseInternalRangeChecker range_checking_policy;
0935         typedef Trunc<unsigned short> rounding_policy;
0936     };
0937
0938     template <>
0939     struct numeric_cast_traits
0940         <
0941             unsigned int
0942           , int
0943         >
0944     {
0945         typedef def_overflow_handler overflow_policy;
0946         typedef UseInternalRangeChecker range_checking_policy;
0947         typedef Trunc<int> rounding_policy;
0948     };
0949
0950     template <>
0951     struct numeric_cast_traits
0952         <
0953             unsigned int
0954           , unsigned int
0955         >
0956     {
0957         typedef def_overflow_handler overflow_policy;
0958         typedef UseInternalRangeChecker range_checking_policy;
0959         typedef Trunc<unsigned int> rounding_policy;
0960     };
0961
0962     template <>
0963     struct numeric_cast_traits
0964         <
0965             unsigned int
0966           , long
0967         >
0968     {
0969         typedef def_overflow_handler overflow_policy;
0970         typedef UseInternalRangeChecker range_checking_policy;
0971         typedef Trunc<long> rounding_policy;
0972     };
0973
0974     template <>
0975     struct numeric_cast_traits
0976         <
0977             unsigned int
0978           , unsigned long
0979         >
0980     {
0981         typedef def_overflow_handler overflow_policy;
0982         typedef UseInternalRangeChecker range_checking_policy;
0983         typedef Trunc<unsigned long> rounding_policy;
0984     };
0985
0986     template <>
0987     struct numeric_cast_traits
0988         <
0989             unsigned int
0990           , float
0991         >
0992     {
0993         typedef def_overflow_handler overflow_policy;
0994         typedef UseInternalRangeChecker range_checking_policy;
0995         typedef Trunc<float> rounding_policy;
0996     };
0997
0998     template <>
0999     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 }}