This commit was manufactured by cvs2svn to create tag

'Version_1_28_0'.

[SVN r13949]

include/boost/cast.hpp

@@ -48,7 +48,6 @@
 # include <typeinfo>
 # include <boost/type.hpp>
 # include <boost/limits.hpp>
-# include <boost/detail/select_type.hpp>
 
 //  It has been demonstrated numerous times that MSVC 6.0 fails silently at link
 //  time if you use a template function which has template parameters that don't
@@ -126,77 +125,54 @@ namespace boost
   
     namespace detail
     {
-      template <class T>
-      struct signed_numeric_limits : std::numeric_limits<T>
-      {
-             static inline T min()
+       template <bool is_signed> struct numeric_min_select;
+    
+       template<>
+       struct numeric_min_select<true>
+       {
+         template <class T>
+         struct limits : std::numeric_limits<T>
          {
-             return std::numeric_limits<T>::min() >= 0
+         static inline T min()
+# ifndef __GNUC__ // bug workaround courtesy Jens Maurer
+             {
+                 return std::numeric_limits<T>::min() >= 0
                      // unary minus causes integral promotion, thus the static_cast<>
                      ? static_cast<T>(-std::numeric_limits<T>::max())
                      : std::numeric_limits<T>::min();
+             }
+# else
+                 ;
+# endif
          };
+       };
+
+# ifdef __GNUC__ // bug workaround courtesy Jens Maurer
+      template<> template<class T>
+      inline T numeric_min_select<true>::limits<T>::min()
+      {
+           return std::numeric_limits<T>::min() >= 0
+               // unary minus causes integral promotion, thus the static_cast<>
+               ? static_cast<T>(-std::numeric_limits<T>::max())
+               : std::numeric_limits<T>::min();
+      }
+# endif
+    
+      template<>
+      struct numeric_min_select<false>
+      {
+          template <class T>
+          struct limits : std::numeric_limits<T> {};
       };
-   
-      // Move to namespace boost in utility.hpp?
-      template <class T, bool specialized>
-      struct fixed_numeric_limits_base
-          : public if_true< std::numeric_limits<T>::is_signed >
-           ::template then< signed_numeric_limits<T>,
-                            std::numeric_limits<T>
-                   >::type
-      {};
       
+      // Move to namespace boost in utility.hpp?
       template <class T>
       struct fixed_numeric_limits
-          : fixed_numeric_limits_base<T,(std::numeric_limits<T>::is_specialized)>
-      {};
-
-# ifdef BOOST_HAS_LONG_LONG
-      // cover implementations which supply no specialization for long
-      // long / unsigned long long. Not intended to be full
-      // numeric_limits replacements, but good enough for numeric_cast<>
-      template <>
-      struct fixed_numeric_limits_base<long long, false>
+          : public numeric_min_select<
+                       std::numeric_limits<T>::is_signed 
+                   >::template limits<T>
       {
-          BOOST_STATIC_CONSTANT(bool, is_specialized = true);
-          BOOST_STATIC_CONSTANT(bool, is_signed = true);
-          static long long max()
-          {
-#  ifdef LONGLONG_MAX
-              return LONGLONG_MAX;
-#  else
-              return 9223372036854775807LL; // hope this is portable
-#  endif 
-          }
-
-          static long long min()
-          {
-#  ifdef LONGLONG_MIN
-              return LONGLONG_MIN;
-#  else  
-              return -9223372036854775808LL; // hope this is portable
-#  endif 
-          }
       };
-
-      template <>
-      struct fixed_numeric_limits_base<unsigned long long, false>
-      {
-          BOOST_STATIC_CONSTANT(bool, is_specialized = true);
-          BOOST_STATIC_CONSTANT(bool, is_signed = false);
-          static unsigned long long max()
-          {
-#  ifdef ULONGLONG_MAX
-              return ULONGLONG_MAX;
-#  else
-              return 0xffffffffffffffffULL; // hope this is portable
-#  endif 
-          }
-
-          static unsigned long long min() { return 0; }
-      };
-# endif 
     } // namespace detail
   
 // less_than_type_min -
@@ -260,24 +236,6 @@ namespace boost
         template <class X, class Y>
         static inline bool check(X x, Y)
             { return x >= 0 && static_cast<X>(static_cast<Y>(x)) != x; }
-        
-# if defined(BOOST_MSVC) && BOOST_MSVC <= 1200
-        // MSVC6 can't static_cast  unsigned __int64 -> floating types
-#  define BOOST_UINT64_CAST(src_type)                                   \
-        static inline bool check(src_type x, unsigned __int64)          \
-        {                                                               \
-            if (x < 0) return false;                                    \
-            unsigned __int64 y = static_cast<unsigned __int64>(x);      \
-            bool odd = y & 0x1;                                         \
-            __int64 div2 = static_cast<__int64>(y >> 1);                \
-            return ((static_cast<src_type>(div2) * 2.0) + odd) != x;    \
-        }
-
-        BOOST_UINT64_CAST(long double);
-        BOOST_UINT64_CAST(double);
-        BOOST_UINT64_CAST(float);
-#  undef BOOST_UINT64_CAST
-# endif 
     };
 
     template<>
@@ -334,7 +292,7 @@ namespace boost
     inline Target numeric_cast(Source arg BOOST_EXPLICIT_DEFAULT_TARGET)
     {
         // typedefs abbreviating respective trait classes
-        typedef detail::fixed_numeric_limits<Source> arg_traits;
+        typedef std::numeric_limits<Source> arg_traits;
         typedef detail::fixed_numeric_limits<Target> result_traits;
         
 #if !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || defined(BOOST_SGI_CPP_LIMITS)

lexical_cast.htm

@@ -79,13 +79,8 @@ convenience for such conversions. For more involved conversions, such as where
 precision or formatting need tighter control than is offered by the default
 behavior of <code>lexical_cast</code>, the conventional
 <code>stringstream</code> approach is recommended. Where the conversions are
-numeric to numeric, <code><a href="cast.htm#numeric_cast">numeric_cast</a></code>
-may offer more reasonable behavior than <code>lexical_cast</code>.
-<p>
-For a good discussion of the options and issues involved in string-based formatting,
-including comparison of <code>stringstream</code>, <code>lexical_cast</code>, and
-others, see Herb Sutter's article, <a href="http://www.gotw.ca/publications/mill19.htm">
-<i>The String Formatters of Manor Farm</i></a>.
+numeric to numeric, <code><a href="cast.htm#numeric_cast">numeric_cast</a></code> may offer more reasonable
+behavior than <code>lexical_cast</code>.
 <p>
 
 <hr>
@@ -159,8 +154,12 @@ template&lt;typename Target, typename Source&gt;
 </blockquote>
 
 Returns the result of streaming <code>arg</code> into a <code>std::stringstream</code> and then
-out as a <code>Target</code> object. If the conversion is unsuccessful, a
-<a href="#bad_lexical_cast"><code>bad_lexical_cast</code></a> exception is thrown.
+out as a <code>Target</code> object. The conversion is parameterized by the current
+<a href="#lexical_context"><code>lexical_context</code></a>, if set. If the conversion is
+unsuccessful, a <a href="#bad_lexical_cast"><code>bad_lexical_cast</code></a> exception is thrown
+if the current <a href="#lexical_context"><code>lexical_context</code></a> is set for throwing or
+if there is no current <a href="#lexical_context"><code>lexical_context</code></a> set, otherwise a
+<code>Target()</code> is returned.
 <p>
 The requirements on the argument and result types are:
 <ul>
@@ -221,32 +220,23 @@ preference to the standard <code>&lt;sstream&gt;</code> header for out-of-the-bo
 
 <ul>
     <li>
-	Improved string handling, correctly accommodating wide character strings, incompatible
-	<code>basic_string</code> types, and empty strings.
+        A mechanism for providing quality-of-service control is needed, e.g. formatting and exception
+        behavior. In the name of simplicity (and release), the current version strips out an earlier
+        experimental version.
     </li>
     <li>
-	Optimize the use of a stream away for identity conversions.
+        Wide character and incompatible <code>std::basic_string</code> issues need to be catered for.
     </li>
     <li>
         An <code>interpret_cast</code> that performs a <i>do-something-reasonable</i> conversion between
         types. It would, for instance, select between <code>numeric_cast</code> and <code>lexical_cast</code>
-        based on <code>std::numeric_limits&lt;&gt;::is_specialized</code>. This would be an interesting
-	project, but there are no concrete plans to pursue this at the moment.
-    </li>
-    <li>
-        It is also worth mentioning future <i>non-directions</i>: anything that involves adding extra
-	arguments for a conversion operation is not being considered. A custom keyword cast, such as
-	<code>lexical_cast</code>, is intended to look like a built-in cast operator: built-in cast operators
-	take only a single operand. Where a higher degree of control is required over conversions, the
-	standard <code>stringstream</code> offers a more appropriate path. Where non-stream-based conversions
-	are required, <code>lexical_cast</code> is the wrong tool for the job, and so it won't be special-cased
-	for such scenarios.
+        based on <code>std::numeric_limits<>::is_specialized</code>.
     </li>
 </ul>
 
 <hr>
 
-<div align="right"><small><i>&copy; Copyright Kevlin Henney, 2000, 2002</i></small></div>
+<div align="right"><small><i>&copy; Copyright Kevlin Henney, 2000</i></small></div>
 
 </body>
 </html>