dep/ACE_wrappers/ace/Truncate.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  * @file Truncate.h
   6  *
   7  * $Id: Truncate.h 82623 2008-08-13 14:41:09Z johnnyw $
   8  *
   9  * @author Steve Huston  <shuston@riverace.com>
  10  * @author Ossama Othman <ossama_othman@symantec.com>
  11  * @author Russell Mora  <russell_mora@symantec.com>
  12  */
  13 //=============================================================================
  14
  15 #ifndef ACE_TRUNCATE_H
  16 #define ACE_TRUNCATE_H
  17
  18 #include /**/ "ace/pre.h"
  19
  20 #include "ace/config-all.h"
  21
  22 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  23 # pragma once
  24 #endif /* ACE_LACKS_PRAGMA_ONCE */
  25
  26 #include "ace/Global_Macros.h"
  27 #include "ace/If_Then_Else.h"
  28 #include "ace/Numeric_Limits.h"
  29
  30 #if defined (ACE_LACKS_LONGLONG_T) \
  31     || defined (__BORLANDC__) && __BORLANDC__ < 0x590
  32 # include "ace/Basic_Types.h"
  33 #endif  /* ACE_LACKS_LONGLONG_T || __BORLANDC__ < 0x590 */
  34
  35 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  36
  37 namespace ACE_Utils
  38 {
  39
  40 #if !defined (__BORLANDC__) || __BORLANDC__ >= 0x590
  41
  42   template<typename T> struct Sign_Check;
  43
  44   // Specialize the unsigned signed cases.
  45   template<> struct Sign_Check<unsigned char>  { ACE_STATIC_CONSTANT (bool, is_signed = 0); };
  46   template<> struct Sign_Check<unsigned short> { ACE_STATIC_CONSTANT (bool, is_signed = 0); };
  47   template<> struct Sign_Check<unsigned int>   { ACE_STATIC_CONSTANT (bool, is_signed = 0); };
  48   template<> struct Sign_Check<unsigned long>  { ACE_STATIC_CONSTANT (bool, is_signed = 0); };
  49 #if !(defined(ACE_LACKS_LONGLONG_T) || defined(ACE_LACKS_UNSIGNEDLONGLONG_T))
  50 # ifdef __GNUC__
  51   // Silence g++ "-pedantic" warnings regarding use of "long long"
  52   // type.
  53   __extension__
  54 # endif  /* __GNUC__ */
  55   template<> struct Sign_Check<unsigned long long> { ACE_STATIC_CONSTANT (bool, is_signed = 0); };
  56 #else
  57   template<> struct Sign_Check<ACE_U_LongLong> { ACE_STATIC_CONSTANT (bool, is_signed = 0); };
  58 #endif  /* !ACE_LACKS_LONGLONG_T */
  59
  60   // Specialize the signed cases.
  61   template<> struct Sign_Check<signed char>  { ACE_STATIC_CONSTANT (bool, is_signed = 1); };
  62   template<> struct Sign_Check<signed short> { ACE_STATIC_CONSTANT (bool, is_signed = 1); };
  63   template<> struct Sign_Check<signed int>   { ACE_STATIC_CONSTANT (bool, is_signed = 1); };
  64   template<> struct Sign_Check<signed long>  { ACE_STATIC_CONSTANT (bool, is_signed = 1); };
  65 #ifndef ACE_LACKS_LONGLONG_T
  66 # ifdef __GNUC__
  67   // Silence g++ "-pedantic" warnings regarding use of "long long"
  68   // type.
  69   __extension__
  70 # endif  /* __GNUC__ */
  71   template<> struct Sign_Check<signed long long> { ACE_STATIC_CONSTANT (bool, is_signed = 1); };
  72 #endif  /* !ACE_LACKS_LONGLONG_T */
  73
  74   // -----------------------------------------------------
  75
  76   /**
  77    * @struct To_Unsigned
  78    *
  79    * @brief Retrieve unsigned counterpart to given type or value.
  80    *
  81    * Retrieve unsigned counterpart to given type or value.
  82    */
  83   template<typename T> struct To_Unsigned;
  84
  85   template<>
  86   struct To_Unsigned<unsigned char>
  87   {
  88     typedef unsigned char unsigned_type;
  89
  90     unsigned_type operator() (unsigned_type x) { return x; }
  91   };
  92
  93   template<>
  94   struct To_Unsigned<unsigned short>
  95   {
  96     typedef unsigned short unsigned_type;
  97
  98     unsigned_type operator() (unsigned_type x) { return x; }
  99   };
 100
 101   template<>
 102   struct To_Unsigned<unsigned int>
 103   {
 104     typedef unsigned int unsigned_type;
 105
 106     unsigned_type operator() (unsigned_type x) { return x; }
 107   };
 108
 109   template<>
 110   struct To_Unsigned<unsigned long>
 111   {
 112     typedef unsigned long unsigned_type;
 113
 114     unsigned_type operator() (unsigned_type x) { return x; }
 115   };
 116
 117 #if !(defined(ACE_LACKS_LONGLONG_T) || defined(ACE_LACKS_UNSIGNEDLONGLONG_T))
 118 # ifdef __GNUC__
 119   // Silence g++ "-pedantic" warnings regarding use of "long long"
 120   // type.
 121   __extension__
 122 # endif  /* __GNUC__ */
 123   template<>
 124   struct To_Unsigned<unsigned long long>
 125   {
 126     typedef unsigned long long unsigned_type;
 127
 128     unsigned_type operator() (unsigned_type x) { return x; }
 129   };
 130 #else
 131   template<>
 132   struct To_Unsigned<ACE_U_LongLong>
 133   {
 134     typedef ACE_U_LongLong unsigned_type;
 135
 136     unsigned_type operator() (unsigned_type x) { return x; }
 137   };
 138 #endif  /* !ACE_LACKS_LONGLONG_T */
 139
 140   // ----------------
 141
 142   template<>
 143   struct To_Unsigned<signed char>
 144   {
 145     typedef signed char   signed_type;
 146     typedef unsigned char unsigned_type;
 147
 148     unsigned_type operator() (signed_type x)
 149     {
 150       return static_cast<unsigned_type> (x);
 151     }
 152   };
 153
 154   template<>
 155   struct To_Unsigned<signed short>
 156   {
 157     typedef signed short   signed_type;
 158     typedef unsigned short unsigned_type;
 159
 160     unsigned_type operator() (signed_type x)
 161     {
 162       return static_cast<unsigned_type> (x);
 163     }
 164   };
 165
 166   template<>
 167   struct To_Unsigned<signed int>
 168   {
 169     typedef signed int   signed_type;
 170     typedef unsigned int unsigned_type;
 171
 172     unsigned_type operator() (signed_type x)
 173     {
 174       return static_cast<unsigned_type> (x);
 175     }
 176   };
 177
 178   template<>
 179   struct To_Unsigned<signed long>
 180   {
 181     typedef signed long   signed_type;
 182     typedef unsigned long unsigned_type;
 183
 184     unsigned_type operator() (signed_type x)
 185     {
 186       return static_cast<unsigned_type> (x);
 187     }
 188   };
 189
 190 #if !(defined(ACE_LACKS_LONGLONG_T) || defined(ACE_LACKS_UNSIGNEDLONGLONG_T))
 191 # ifdef __GNUC__
 192   // Silence g++ "-pedantic" warnings regarding use of "long long"
 193   // type.
 194   __extension__
 195 # endif  /* __GNUC__ */
 196   template<>
 197   struct To_Unsigned<signed long long>
 198   {
 199     typedef signed long long   signed_type;
 200     typedef unsigned long long unsigned_type;
 201
 202     unsigned_type operator() (signed_type x)
 203     {
 204       return static_cast<unsigned_type> (x);
 205     }
 206   };
 207 #endif  /* !ACE_LACKS_LONGLONG_T */
 208
 209   // -----------------------------------------------------
 210
 211   /**
 212    * @struct Safe_Comparator
 213    *
 214    * @brief Conservative comparison of types that may not be safely
 215    *        promoted and/or converted to each other.
 216    *
 217    * The comparison operations provided by this structure perform
 218    * negative value checking when necessary to prevent wrap-around
 219    * when explicitly casting to an unsigned type.
 220    *
 221    * @internal This structure is not meant for general use.
 222    */
 223   template<typename LEFT,
 224            typename RIGHT,
 225            bool IS_LEFT_SIGNED,
 226            bool IS_RIGHT_SIGNED> struct Safe_Comparator;
 227
 228   // LEFT: signed, RIGHT: unsigned
 229   template<typename LEFT, typename RIGHT>
 230   struct Safe_Comparator<LEFT, RIGHT, true, false>
 231   {
 232     static bool greater_than (LEFT lhs, RIGHT rhs)
 233     {
 234       // Prevent wrap-around when casting to unsigned.
 235       if (lhs < 0)
 236         return false;  // since rhs is always positive
 237       else
 238         {
 239           // Implicit promotion of unsigned LEFT and RIGHT types here.
 240           return To_Unsigned<LEFT>() (lhs) > rhs;
 241         }
 242     }
 243   };
 244
 245   // LEFT: unsigned, RIGHT: signed
 246   template<typename LEFT, typename RIGHT>
 247   struct Safe_Comparator<LEFT, RIGHT, false, true>
 248   {
 249     static bool greater_than (LEFT lhs, RIGHT rhs)
 250     {
 251       // Prevent wrap-around when casting to unsigned.
 252       if (rhs < 0)
 253         return true;  // since lhs is always positive
 254       else
 255         {
 256           // Implicit promotion of unsigned LEFT and RIGHT types here.
 257           return lhs > To_Unsigned<RIGHT>() (rhs);
 258         }
 259     }
 260   };
 261
 262   // LEFT: unsigned, RIGHT: unsigned
 263   template<typename LEFT, typename RIGHT>
 264   struct Safe_Comparator<LEFT, RIGHT, false, false>
 265   {
 266     static bool greater_than (LEFT lhs, RIGHT rhs)
 267     {
 268       // Implicit promotion of unsigned LEFT and RIGHT types here.
 269       return lhs > rhs;
 270     }
 271   };
 272
 273   // LEFT: signed, RIGHT: signed
 274   template<typename LEFT, typename RIGHT>
 275   struct Safe_Comparator<LEFT, RIGHT, true, true>
 276   {
 277     static bool greater_than (LEFT lhs, RIGHT rhs)
 278     {
 279       // Implicit promotion of signed LEFT and RIGHT types here.
 280       return lhs > rhs;
 281     }
 282   };
 283
 284   // -----------------------------------------------------
 285
 286   /**
 287    * @struct Fast_Comparator
 288    *
 289    * @brief Quick comparison of types that can be safely promoted
 290    *        and/or converted to each other.
 291    *
 292    * The comparison operations provided by this structure perform no
 293    * negative value checking, meaning it is not applicable to all
 294    * types.  Check the value of the @c USABLE enumerator to determine
 295    * if it applies to the types in question.
 296    *
 297    * @internal This structure is not meant for general use.
 298    */
 299   template<typename LEFT, typename RIGHT>
 300   struct Fast_Comparator
 301   {
 302     ACE_STATIC_CONSTANT (
 303       bool,
 304       USE_LEFT  = ((sizeof (LEFT) > sizeof (RIGHT)
 305                     && (Sign_Check<LEFT>::is_signed == 1
 306                         || Sign_Check<RIGHT>::is_signed == 0))
 307
 308                    // The following is basically the case where LEFT
 309                    // and RIGHT are the same integral type.
 310                    || (sizeof (LEFT) == sizeof (RIGHT)
 311                        // Can't portably do
 312                        // Sign_Check<LEFT>::is_signed ==
 313                        // Sign_Check<RIGHT>::is_signed,
 314                        // i.e. comparison of anonymous enumerations,
 315                        // without triggering a compiler diagnostic
 316                        // so expand the comparison.
 317                        && ((Sign_Check<LEFT>::is_signed == 1
 318                             && Sign_Check<RIGHT>::is_signed == 1)
 319                            || (Sign_Check<LEFT>::is_signed == 0
 320                                && Sign_Check<RIGHT>::is_signed == 0)))));
 321
 322     ACE_STATIC_CONSTANT (
 323       bool,
 324       USE_RIGHT = (sizeof (RIGHT) > sizeof (LEFT)
 325                    && (Sign_Check<RIGHT>::is_signed == 1
 326                        || Sign_Check<LEFT>::is_signed == 0)));
 327
 328     ACE_STATIC_CONSTANT (bool, USABLE = (USE_LEFT || USE_RIGHT));
 329
 330     typedef typename ACE::If_Then_Else<
 331       USE_LEFT,
 332       LEFT,
 333       typename ACE::If_Then_Else<
 334         USE_RIGHT,
 335         RIGHT,
 336         void>::result_type>::result_type promote_type;
 337
 338     static bool greater_than (LEFT lhs, RIGHT rhs)
 339     {
 340       // The explicit cast is assumed to change the type of rhs without
 341       // changing its value.
 342       return
 343         (static_cast<promote_type> (lhs) > static_cast<promote_type> (rhs));
 344     }
 345
 346   };
 347
 348   // -----------------------------------------------------
 349
 350   /**
 351    * @struct Comparator
 352    *
 353    * @brief Structure that provides optimal comparison operation for
 354    *        given types.
 355    *
 356    * The comparison operations provided by this structure are chosen
 357    * at compile time based on the signs and sizes of types being
 358    * compared.
 359    * @par
 360    * Comparisons of values with the same sign or those with types that
 361    * can be promoted safely are done quickly, without any range
 362    * checking.
 363    * @par
 364    * Comparisons of values of different types that cannot be safely
 365    * promoted incur an additional check for a negative value to allow
 366    * the compiler to perform the appropriate implicit unsigned type
 367    * promotion.
 368    *
 369    * @note In general, the operations found in this structure should
 370    *       not be used to work around compiler diagnostics regarding
 371    *       comparison of signed and unsigned types.  Verify that your
 372    *       types are correct before relying on those operations.
 373    *
 374    * @internal This structure is not meant for general use.
 375    */
 376   template<typename LEFT, typename RIGHT>
 377   struct Comparator
 378   {
 379     typedef typename ACE::If_Then_Else<
 380       Fast_Comparator<LEFT, RIGHT>::USABLE,
 381       Fast_Comparator<LEFT, RIGHT>,
 382       Safe_Comparator<LEFT,
 383                       RIGHT,
 384                       Sign_Check<LEFT>::is_signed,
 385                       Sign_Check<RIGHT>::is_signed> >::result_type comp_type;
 386   };
 387
 388   // -----------------------------------------------------
 389
 390   /**
 391    * @struct Truncator
 392    *
 393    * @brief Truncate value of type @c FROM to value of type @c TO.
 394    *
 395    * Truncate a value of type @c FROM to value of type @c TO, if the
 396    * value is larger than the maximum of value of type @c TO.
 397    */
 398   template<typename FROM, typename TO>
 399   struct Truncator
 400   {
 401     ACE_STATIC_CONSTANT (
 402       bool,
 403       // max FROM always greater than max TO
 404       MAX_FROM_GT_MAX_TO = (sizeof(FROM) > sizeof (TO)
 405                             || (sizeof(FROM) == sizeof (TO)
 406                                 && Sign_Check<FROM>::is_signed == 0)));
 407
 408     typedef typename ACE::If_Then_Else<
 409       MAX_FROM_GT_MAX_TO,
 410       FROM,
 411       TO>::result_type comp_to_type;
 412
 413     // Take advantage of knowledge that we're casting a positive value
 414     // to a type large enough to hold it so that we can bypass
 415     // negative value checks at compile-time.  Otherwise fallback on
 416     // the safer comparison.
 417     typedef typename ACE::If_Then_Else<
 418       MAX_FROM_GT_MAX_TO,
 419       Fast_Comparator<FROM, comp_to_type>,
 420       typename Comparator<FROM, comp_to_type>::comp_type>::result_type comparator;
 421
 422     /// Truncate a value of type @c FROM to value of type @c TO, if
 423     /// the value is larger than the maximum of value of type @c TO.
 424     TO operator() (FROM val)
 425     {
 426       return
 427         (comparator::greater_than (val, ACE_Numeric_Limits<TO>::max ())
 428          ? ACE_Numeric_Limits<TO>::max ()
 429          : static_cast<TO> (val));
 430     }
 431
 432   };
 433
 434   // Partial specialization for the case where the types are the same.
 435   // No truncation is necessary.
 436   template<typename T>
 437   struct Truncator<T, T>
 438   {
 439     T operator() (T val)
 440     {
 441       return val;
 442     }
 443   };
 444
 445
 446 #if defined (ACE_LACKS_LONGLONG_T) || defined (ACE_LACKS_UNSIGNEDLONGLONG_T)
 447   // Partial specialization for the case where we're casting from
 448   // ACE_U_LongLong to a smaller integer.  We assume that we're always
 449   // truncating from ACE_U_LongLong to a smaller type.  The partial
 450   // specialization above handles the case where both the FROM and TO
 451   // types are ACE_U_LongLong.
 452   template<typename TO>
 453   struct Truncator<ACE_U_LongLong, TO>
 454   {
 455     TO operator() (ACE_U_LongLong const & val)
 456     {
 457       // If val less than or equal to ACE_Numeric_Limits<TO>::max(),
 458       // val.lo() must be less than or equal to
 459       // ACE_Numeric_Limits<TO>::max (), as well.
 460       return
 461         (val > ACE_Numeric_Limits<TO>::max ()
 462          ? ACE_Numeric_Limits<TO>::max ()
 463          : static_cast<TO> (val.lo ()));
 464     }
 465   };
 466 #endif /* ACE_LACKS_LONGLONG_T || ACE_LACKS_UNSIGNEDLONGLONG_T */
 467
 468   // -----------------------------------------------------
 469   /**
 470    * @struct Noop_Truncator
 471    *
 472    * @brief No-op truncation.
 473    *
 474    * This structure/functor performs no truncation since it assumes
 475    * that @c sizeof(FROM) @c < @c sizeof(TO), meaning that
 476    * @c numeric_limits<FROM>::max() @c < @c numeric_limits<TO>::max().
 477    */
 478   template<typename FROM, typename TO>
 479   struct Noop_Truncator
 480   {
 481     TO operator() (FROM val)
 482     {
 483       return static_cast<TO> (val);
 484     }
 485   };
 486   // -----------------------------------------------------
 487
 488   /**
 489    * @class truncate_cast
 490    *
 491    * @brief Helper function to truncate an integral value to the
 492    *        maximum  value of the given type.
 493    *
 494    *        Very useful since ACE methods return @c int very often and
 495    *        the value's source is often a different-size integral
 496    *        type, such as @c size_t.  This function hides the
 497    *        truncation logic and resolves compiler diagnostics.
 498    *
 499    * @internal Internal use only.
 500    */
 501   template<typename TO, typename FROM>
 502   inline TO truncate_cast (FROM val)
 503   {
 504     // If the size of FROM is less than the size of TO, "val" will
 505     // never be greater than the maximum "TO" value, so there is no
 506     // need to attempt to truncate.
 507     typedef typename ACE::If_Then_Else<
 508       (sizeof (FROM) < sizeof (TO)),
 509       Noop_Truncator<FROM, TO>,
 510       Truncator<FROM, TO> >::result_type truncator;
 511
 512     return truncator() (val);
 513   }
 514
 515 #else
 516
 517   // Borland can't handle the template meta-programming above so
 518   // provide explicit specializations for a few types.  More will be
 519   // added if necessary.
 520
 521   /**
 522    * @deprecated Borland ACE_Utils::Truncator<> specializations should
 523    *             be removed.
 524    */
 525
 526   template<typename FROM, typename TO> struct Truncator;
 527
 528   //----------------------------------------------------------
 529   // sizeof(FROM) >  sizeof(TO)
 530   //----------------------------------------------------------
 531
 532   template<>
 533   struct Truncator<ACE_INT32, ACE_INT8>
 534   {
 535     ACE_INT8 operator() (ACE_INT32 val)
 536     {
 537       return
 538         (val > ACE_Numeric_Limits<ACE_INT8>::max ()
 539          ? ACE_Numeric_Limits<ACE_INT8>::max ()
 540          : static_cast<ACE_INT8> (val));
 541     }
 542   };
 543
 544   template<>
 545   struct Truncator<ACE_UINT32, ACE_UINT8>
 546   {
 547     ACE_UINT8 operator() (ACE_UINT32 val)
 548     {
 549       return
 550         (val > static_cast<ACE_UINT32> (ACE_Numeric_Limits<ACE_UINT8>::max ())
 551          ? ACE_Numeric_Limits<ACE_UINT8>::max ()
 552          : static_cast<ACE_UINT8> (val));
 553     }
 554   };
 555
 556   template<>
 557   struct Truncator<ACE_INT32, ACE_UINT8>
 558   {
 559     ACE_UINT8 operator() (ACE_INT32 val)
 560     {
 561       return
 562         (val > static_cast<ACE_INT32> (ACE_Numeric_Limits<ACE_UINT8>::max ())
 563          ? ACE_Numeric_Limits<ACE_UINT8>::max ()
 564          : static_cast<ACE_UINT8> (val));
 565     }
 566   };
 567
 568   template<>
 569   struct Truncator<ACE_UINT32, ACE_INT8>
 570   {
 571     ACE_INT8 operator() (ACE_UINT32 val)
 572     {
 573       return
 574         (val > static_cast<ACE_UINT32> (ACE_Numeric_Limits<ACE_INT8>::max ())
 575          ? ACE_Numeric_Limits<ACE_INT8>::max ()
 576          : static_cast<ACE_INT8> (val));
 577     }
 578   };
 579
 580 #if defined (ACE_SIZEOF_LONG) && ACE_SIZEOF_LONG < 8
 581   template<>
 582   struct Truncator<ACE_INT64, signed long>
 583   {
 584     signed long operator() (ACE_INT64 val)
 585     {
 586       return
 587         (val > ACE_Numeric_Limits<signed long>::max ()
 588          ? ACE_Numeric_Limits<signed long>::max ()
 589          : static_cast<signed long> (val));
 590     }
 591   };
 592
 593   template<>
 594   struct Truncator<ACE_INT64, unsigned long>
 595   {
 596     unsigned long operator() (ACE_INT64 val)
 597     {
 598       return
 599         (val > static_cast<ACE_INT64> (ACE_Numeric_Limits<unsigned long>::max ())
 600          ? ACE_Numeric_Limits<unsigned long>::max ()
 601          : static_cast<unsigned long> (val));
 602     }
 603   };
 604
 605   template<>
 606   struct Truncator<ACE_UINT64, unsigned long>
 607   {
 608     unsigned long operator() (ACE_UINT64 val)
 609     {
 610       return
 611         (val > static_cast<ACE_UINT64> (ACE_Numeric_Limits<unsigned long>::max ())
 612          ? ACE_Numeric_Limits<unsigned long>::max ()
 613          : static_cast<unsigned long> (val));
 614     }
 615   };
 616
 617   template<>
 618   struct Truncator<ACE_UINT64, signed long>
 619   {
 620     signed long operator() (ACE_UINT64 val)
 621     {
 622       return
 623         (val > static_cast<ACE_UINT64> (ACE_Numeric_Limits<signed long>::max ())
 624          ? ACE_Numeric_Limits<signed long>::max ()
 625          : static_cast<signed long> (val));
 626     }
 627   };
 628
 629   template<>
 630   struct Truncator<const ACE_UINT64, signed long>
 631   {
 632     signed long operator() (const ACE_UINT64 val)
 633     {
 634       return
 635         (val > static_cast<ACE_UINT64> (ACE_Numeric_Limits<signed long>::max ())
 636          ? ACE_Numeric_Limits<signed long>::max ()
 637          : static_cast<signed long> (val));
 638     }
 639   };
 640
 641 #endif  /* ACE_SIZEOF_LONG < 8 */
 642
 643 #if defined (ACE_SIZEOF_INT) && ACE_SIZEOF_INT < 8
 644   template<>
 645   struct Truncator<ACE_INT64, signed int>
 646   {
 647     ACE_INT32 operator() (ACE_INT64 val)
 648     {
 649       return
 650         (val > ACE_Numeric_Limits<signed int>::max ()
 651          ? ACE_Numeric_Limits<signed int>::max ()
 652          : static_cast<signed int> (val));
 653     }
 654   };
 655
 656   template<>
 657   struct Truncator<ACE_INT64, unsigned int>
 658   {
 659     ACE_UINT32 operator() (ACE_INT64 val)
 660     {
 661       return
 662         (val > static_cast<ACE_INT64> (ACE_Numeric_Limits<unsigned int>::max ())
 663          ? ACE_Numeric_Limits<unsigned int>::max ()
 664          : static_cast<unsigned int> (val));
 665     }
 666   };
 667
 668   template<>
 669   struct Truncator<ACE_UINT64, unsigned int>
 670   {
 671     ACE_UINT32 operator() (ACE_UINT64 val)
 672     {
 673       return
 674         (val > static_cast<ACE_UINT64> (ACE_Numeric_Limits<unsigned int>::max ())
 675          ? ACE_Numeric_Limits<unsigned int>::max ()
 676          : static_cast<unsigned int> (val));
 677     }
 678   };
 679
 680   template<>
 681   struct Truncator<ACE_UINT64, signed int>
 682   {
 683     signed int operator() (ACE_UINT64 val)
 684     {
 685       return
 686         (val > static_cast<ACE_UINT64> (ACE_Numeric_Limits<signed int>::max ())
 687          ? ACE_Numeric_Limits<signed int>::max ()
 688          : static_cast<signed int> (val));
 689     }
 690   };
 691
 692 #endif  /* ACE_SIZEOF_INT < 8 */
 693
 694   //----------------------------------------------------------
 695   // sizeof(FROM) == sizeof(TO)
 696   //----------------------------------------------------------
 697
 698   template<>
 699   struct Truncator<unsigned int, char>
 700   {
 701     char operator() (unsigned int val)
 702     {
 703       return static_cast<char> (val);
 704     }
 705   };
 706
 707   template<>
 708   struct Truncator<unsigned int, wchar_t>
 709   {
 710     wchar_t operator() (unsigned int val)
 711     {
 712       return static_cast<wchar_t> (val);
 713     }
 714   };
 715
 716   template<>
 717   struct Truncator<signed int, unsigned int>
 718   {
 719     unsigned int operator() (signed int val)
 720     {
 721       return static_cast<unsigned int> (val);
 722     }
 723   };
 724
 725   template<>
 726   struct Truncator<unsigned int, signed int>
 727   {
 728     signed int operator() (unsigned int val)
 729     {
 730       return
 731         (val > static_cast<unsigned int> (ACE_Numeric_Limits<signed int>::max ())
 732          ? ACE_Numeric_Limits<signed int>::max ()
 733          : static_cast<signed int> (val));
 734     }
 735   };
 736
 737   template<>
 738   struct Truncator<const unsigned int, signed int>
 739   {
 740     signed int operator() (const unsigned int val)
 741     {
 742       return
 743         (val > static_cast<unsigned int> (ACE_Numeric_Limits<signed int>::max ())
 744          ? ACE_Numeric_Limits<signed int>::max ()
 745          : static_cast<signed int> (val));
 746     }
 747   };
 748
 749   template<>
 750   struct Truncator<signed long, unsigned long>
 751   {
 752     unsigned long operator() (signed long val)
 753     {
 754       return static_cast<unsigned long> (val);
 755     }
 756   };
 757
 758   template<>
 759   struct Truncator<unsigned long, signed long>
 760   {
 761     signed long operator() (unsigned long val)
 762     {
 763       return
 764         (val > static_cast<unsigned long> (ACE_Numeric_Limits<signed long>::max ())
 765          ? ACE_Numeric_Limits<signed long>::max ()
 766          : static_cast<signed long> (val));
 767     }
 768   };
 769
 770 #if defined (ACE_SIZEOF_INT) && defined (ACE_SIZEOF_LONG) \
 771     && ACE_SIZEOF_INT == ACE_SIZEOF_LONG
 772
 773   template<>
 774   struct Truncator<signed int, unsigned long>
 775   {
 776     unsigned long operator() (signed int val)
 777     {
 778       return static_cast<unsigned long> (val);
 779     }
 780   };
 781
 782   template<>
 783   struct Truncator<signed int, signed long>
 784   {
 785     signed long operator() (signed int val)
 786     {
 787       return static_cast<signed long> (val);
 788     }
 789   };
 790
 791   template<>
 792   struct Truncator<unsigned long, signed int>
 793   {
 794     signed int operator() (unsigned long val)
 795     {
 796       return
 797         (val > static_cast<unsigned long> (ACE_Numeric_Limits<signed int>::max ())
 798          ? ACE_Numeric_Limits<signed int>::max ()
 799          : static_cast<signed int> (val));
 800     }
 801   };
 802
 803   template<>
 804   struct Truncator<signed long, signed int>
 805   {
 806     signed int operator() (signed long val)
 807     {
 808       return static_cast<signed int> (val);
 809 //      This code causes asserts and compiler crashes with BCB6 Static and
 810 //      BCB2007 Static
 811 //      return
 812 //        (val > static_cast<signed long> (ACE_Numeric_Limits<signed int>::max ())
 813 //         ? ACE_Numeric_Limits<signed int>::max ()
 814 //         : static_cast<signed int> (val));
 815     }
 816   };
 817
 818   template<>
 819   struct Truncator<signed long, unsigned int>
 820   {
 821     unsigned int operator() (signed long val)
 822     {
 823       return static_cast<unsigned int> (val);
 824     }
 825   };
 826
 827   template<>
 828   struct Truncator<const signed long, unsigned int>
 829   {
 830     unsigned int operator() (const signed long val)
 831     {
 832       return static_cast<unsigned int> (val);
 833     }
 834   };
 835
 836
 837   template<>
 838   struct Truncator<unsigned int, signed long>
 839   {
 840     signed long operator() (unsigned int val)
 841     {
 842       return
 843         (val > static_cast<unsigned int> (ACE_Numeric_Limits<signed long>::max ())
 844          ? ACE_Numeric_Limits<signed long>::max ()
 845          : static_cast<signed long> (val));
 846     }
 847   };
 848
 849 #endif  /* ACE_SIZEOF_INT == ACE_SIZEOF_LONG */
 850
 851   template<>
 852   struct Truncator<ACE_INT64, ACE_UINT64>
 853   {
 854     ACE_UINT64 operator() (ACE_INT64 val)
 855     {
 856       return static_cast<ACE_UINT64> (val);
 857     }
 858   };
 859
 860   template<>
 861   struct Truncator<ACE_UINT64, ACE_INT64>
 862   {
 863     ACE_INT64 operator() (ACE_UINT64 val)
 864     {
 865       return
 866         (val > static_cast<ACE_UINT64> (ACE_Numeric_Limits<ACE_INT64>::max ())
 867          ? ACE_Numeric_Limits<ACE_INT64>::max ()
 868          : static_cast<ACE_INT64> (val));
 869     }
 870   };
 871
 872   //----------------------------------------------------------
 873   // sizeof(FROM) <  sizeof(TO)
 874   //----------------------------------------------------------
 875
 876   template<>
 877   struct Truncator<ACE_INT8, ACE_INT32>
 878   {
 879     ACE_INT32 operator() (ACE_INT8 val)
 880     {
 881       return static_cast<ACE_INT32> (val);
 882     }
 883   };
 884
 885   template<>
 886   struct Truncator<ACE_UINT8, ACE_UINT32>
 887   {
 888     ACE_UINT32 operator() (ACE_UINT8 val)
 889     {
 890       return static_cast<ACE_UINT32> (val);
 891     }
 892   };
 893
 894   template<>
 895   struct Truncator<ACE_UINT8, ACE_INT32>
 896   {
 897     ACE_INT32 operator() (ACE_UINT8 val)
 898     {
 899       return static_cast<ACE_INT32> (val);
 900     }
 901   };
 902
 903   template<>
 904   struct Truncator<ACE_INT8, ACE_UINT32>
 905   {
 906     ACE_UINT32 operator() (ACE_INT8 val)
 907     {
 908       return static_cast<ACE_UINT32> (val);
 909     }
 910   };
 911
 912 #if defined (ACE_SIZEOF_LONG) && ACE_SIZEOF_LONG < 8
 913   template<>
 914   struct Truncator<signed long, ACE_INT64>
 915   {
 916     ACE_INT64 operator() (signed long val)
 917     {
 918       return static_cast<ACE_INT64> (val);
 919     }
 920   };
 921
 922   template<>
 923   struct Truncator<signed long, ACE_UINT64>
 924   {
 925     ACE_UINT64 operator() (signed long val)
 926     {
 927       return static_cast<ACE_UINT64> (val);
 928     }
 929   };
 930
 931   template<>
 932   struct Truncator<const signed long, ACE_UINT64>
 933   {
 934     ACE_UINT64 operator() (const signed long val)
 935     {
 936       return
 937         (val > static_cast<ACE_UINT64> (ACE_Numeric_Limits<signed long>::max ())
 938          ? ACE_Numeric_Limits<signed long>::max ()
 939          : static_cast<signed long> (val));
 940     }
 941   };
 942
 943   template<>
 944   struct Truncator<unsigned long, ACE_UINT64>
 945   {
 946     ACE_UINT64 operator() (unsigned long val)
 947     {
 948       return static_cast<ACE_UINT64> (val);
 949     }
 950   };
 951
 952   template<>
 953   struct Truncator<unsigned long, ACE_INT64>
 954   {
 955     ACE_INT64 operator() (unsigned long val)
 956     {
 957       return static_cast<ACE_INT64> (val);
 958     }
 959   };
 960 #endif  /* ACE_SIZEOF_LONG < 8 */
 961
 962 #if defined (ACE_SIZEOF_INT) && ACE_SIZEOF_INT < 8
 963   template<>
 964   struct Truncator<signed int, ACE_INT64>
 965   {
 966     ACE_INT64 operator() (signed int val)
 967     {
 968       return static_cast<ACE_INT64> (val);
 969     }
 970   };
 971
 972   template<>
 973   struct Truncator<signed int, ACE_UINT64>
 974   {
 975     ACE_UINT64 operator() (signed int val)
 976     {
 977       return static_cast<ACE_UINT64> (val);
 978     }
 979   };
 980
 981   template<>
 982   struct Truncator<unsigned int, ACE_UINT64>
 983   {
 984     ACE_UINT64 operator() (unsigned int val)
 985     {
 986       return static_cast<ACE_UINT64> (val);
 987     }
 988   };
 989
 990   template<>
 991   struct Truncator<unsigned int, ACE_INT64>
 992   {
 993     ACE_INT64 operator() (unsigned int val)
 994     {
 995       return static_cast<ACE_INT64> (val);
 996     }
 997   };
 998 #endif  /* ACE_SIZEOF_INT < 8 */
 999
1000   template<>
1001   struct Truncator<size_t, unsigned long>
1002   {
1003     unsigned long operator() (size_t val)
1004     {
1005       return
1006         (val > static_cast<unsigned long> (ACE_Numeric_Limits<size_t>::max ())
1007          ? ACE_Numeric_Limits<size_t>::max ()
1008          : static_cast<size_t> (val));
1009     }
1010   };
1011
1012   // Partial specialization for the case where the types are the same.
1013   // No truncation is necessary.
1014   template<typename T>
1015   struct Truncator<T, T>
1016   {
1017     T operator() (T val)
1018     {
1019       return val;
1020     }
1021   };
1022
1023   // Partial specialization for the case where the types are the same,
1024   // but the from type is const.  No truncation is necessary.
1025   //
1026   // This is only necessary to workaround a problem with the BCB6
1027   // compiler.
1028   template<typename T>
1029   struct Truncator<T const, T>
1030   {
1031     T operator() (T val)
1032     {
1033       return val;
1034     }
1035   };
1036
1037   // -------------------------------------
1038
1039   template<typename TO, typename FROM>
1040   inline TO truncate_cast (FROM val)
1041   {
1042     typedef Truncator<FROM, TO> truncator;
1043
1044     return truncator() (val);
1045   }
1046
1047 #endif  /* !__BORLANDC__ || __BORLANDC__ >= 0x590 */
1048
1049 } // namespace ACE_Utils
1050
1051 ACE_END_VERSIONED_NAMESPACE_DECL
1052
1053 #include /**/ "ace/post.h"
1054
1055 #endif /* ACE_TRUNCATE_H*/