ACE中对于不同类型数据的最大值最小值管理ACE_Numeric_Limits

对于不同类型的变量，这里定义了其最大最小值来提供给ACE_Utils等使用

 template <typename T> struct ACE_Numeric_Limits;

 // ------------------------------------------
 // Special cases.
 template<>
 struct ACE_Export ACE_Numeric_Limits<char>
 {
   static char min (void) { return CHAR_MIN; }
   static char max (void) { return CHAR_MAX; }
 };

 // ------------------------------------------
 // Signed integers.

 template<>
 struct ACE_Export ACE_Numeric_Limits<signed char>
 {
   static signed char min (void) { return SCHAR_MIN; }
   static signed char max (void) { return SCHAR_MAX; }
 };

 template<>
 struct ACE_Export ACE_Numeric_Limits<signed short>
 {
   static signed short min (void) { return SHRT_MIN; }
   static signed short max (void) { return SHRT_MAX; }
 };

 template<>
 struct ACE_Export ACE_Numeric_Limits<signed int>
 {
   static signed int min (void) { return INT_MIN; }
   static signed int max (void) { return INT_MAX; }
 };

 template<>
 struct ACE_Export ACE_Numeric_Limits<signed long>
 {
   static signed long min (void) { return LONG_MIN; }
   static signed long max (void) { return LONG_MAX; }
 };

 template<>
 struct ACE_Export ACE_Numeric_Limits<signed long long>
 {
 #if defined (LLONG_MIN)
 #  define ACE_LLONG_MIN LLONG_MIN
 #elif defined (LONG_LONG_MIN)
 #  define ACE_LLONG_MIN LONG_LONG_MIN
 #elif defined (LONGLONG_MIN)
 #  define ACE_LLONG_MIN LONGLONG_MIN
 #else
 #  error Unable to determine minimum signed long long value.
 #endif  /* LLONG_MIN */

 #if defined (LLONG_MAX)
 #  define ACE_LLONG_MAX LLONG_MAX
 #elif defined (LONG_LONG_MAX)
 #  define ACE_LLONG_MAX LONG_LONG_MAX
 #elif defined (LONGLONG_MAX)
 #  define ACE_LLONG_MAX LONGLONG_MAX
 #else
 #  error Unable to determine maximum signed long long value.
 #endif  /* LLONG_MAX */

   static signed long long min (void) { return ACE_LLONG_MIN; }
   static signed long long max (void) { return ACE_LLONG_MAX; }
 };

 // ------------------------------------------
 // Unsigned integers
 template<>
 struct ACE_Export ACE_Numeric_Limits<unsigned char>
 {
   static unsigned char min (void) { return ; }
   static unsigned char max (void) { return UCHAR_MAX; }
 };

 template<>
 struct ACE_Export ACE_Numeric_Limits<unsigned short>
 {
   static unsigned short min (void) { return ; }
   static unsigned short max (void) { return USHRT_MAX; }
 };

 template<>
 struct ACE_Export ACE_Numeric_Limits<unsigned int>
 {
   static unsigned int min (void) { return ; }
   static unsigned int max (void) { return UINT_MAX; }
 };

 template<>
 struct ACE_Export ACE_Numeric_Limits<unsigned long>
 {
   static unsigned long min (void) { return ; }
   static unsigned long max (void) { return ULONG_MAX; }
 };

 template<>
 struct ACE_Export ACE_Numeric_Limits<unsigned long long>
 {
   static unsigned long long min (void) { return ; }
   static unsigned long long max (void)
   {
 # if defined (ULLONG_MAX)
     return ULLONG_MAX;
 # elif defined (ULONGLONG_MAX)
     return ULONGLONG_MAX;
 # else
 #  error Unable to determine maximum unsigned long long value.
 # endif  /* ULLONG_MAX */
   }
 };

 // ------------------------------------------
 // Floating point types

 template<>
 struct ACE_Export ACE_Numeric_Limits<float>
 {
   static float min (void) { return FLT_MIN; }
   static float max (void) { return FLT_MAX; }
 };

 template<>
 struct ACE_Export ACE_Numeric_Limits<double>
 {
   static double min (void) { return DBL_MIN; }
   static double max (void) { return DBL_MAX; }
 };

 template<>
 struct ACE_Export ACE_Numeric_Limits<long double>
 {
   static long double min (void) { return LDBL_MIN; }
   static long double max (void) { return LDBL_MAX; }
 };

 #else

 // std::numeric_limits<> has all of the necessary specializations.
 // Just wrap it.

 template <typename T>
 struct ACE_Numeric_Limits
 {
   static T min (void) { return std::numeric_limits<T>::min (); }
   static T max (void) { return std::numeric_limits<T>::max (); }
 };

 # if (defined (ACE_WIN64) && defined (_MSC_VER) && _MSC_VER <= ) \
     || defined (ACE_LACKS_NUMERIC_LIMITS_64_BIT_TYPES)
 // The Microsoft Platform SDK does not provide std::numeric_limits<>
 // specializations for 64 bit integers so we need to explicitly provide
 // ACE_Numeric_Limits<> specializations to compensate for this
 // deficiency.
 //
 // Unfortunately there is no way to tell if the platform SDK is being
 // used so we specialize for the ACE_WIN64 + MSVC++ 7.1 case, which is
 // the configuration that exhibits this problem.  It also happens to
 // be a fairly isolated configuration since 64-bit support in MSVC++
 // 7.1 was not very good to begin with.
 template<>
 struct ACE_Numeric_Limits<LONGLONG>
 {
   static LONGLONG min (void) { return _I64_MIN; }
   static LONGLONG max (void) { return _I64_MAX; }
 };

 template<>
 struct ACE_Numeric_Limits<ULONGLONG>
 {
   static ULONGLONG min (void) { return ; }
   static ULONGLONG max (void) { return _UI64_MAX; }
 };
 # endif  /* ACE_WIN64 && _MSC_VER <= 1310 */