1 // Copyright Alexander Nasonov & Paul A. Bristow 2006.
2
3 // Use, modification and distribution are subject to the
4 // Boost Software License, Version 1.0.
5 // (See accompanying file LICENSE_1_0.txt
6 // or copy at http://www.boost.org/LICENSE_1_0.txt)
7
8 #ifndef BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
9 #define BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
10
11 #include <climits>
12 #include <ios>
13 #include <limits>
14
15 #include <boost/config.hpp>
16 #include <boost/integer_traits.hpp>
17
18 #ifndef BOOST_NO_IS_ABSTRACT
19 // Fix for SF:1358600 - lexical_cast & pure virtual functions & VC 8 STL
20 #include <boost/mpl/if.hpp>
21 #include <boost/type_traits/is_abstract.hpp>
22 #endif
23
24 #if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || \
25 (defined(BOOST_MSVC) && (BOOST_MSVC<1310))
26
27 #define BOOST_LCAST_NO_COMPILE_TIME_PRECISION
28 #endif
29
30 #ifdef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
31 #include <boost/assert.hpp>
32 #else
33 #include <boost/static_assert.hpp>
34 #endif
35
36 namespace boost { namespace detail {
37
38 class lcast_abstract_stub {};
39
40 #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
41 // Calculate an argument to pass to std::ios_base::precision from
42 // lexical_cast. See alternative implementation for broken standard
43 // libraries in lcast_get_precision below. Keep them in sync, please.
44 template<class T>
45 struct lcast_precision
46 {
47 #ifdef BOOST_NO_IS_ABSTRACT
48 typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
49 #else
50 typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
51 boost::is_abstract<T>
52 , std::numeric_limits<lcast_abstract_stub>
53 , std::numeric_limits<T>
54 >::type limits;
55 #endif
56
57 BOOST_STATIC_CONSTANT(bool, use_default_precision =
58 !limits::is_specialized || limits::is_exact
59 );
60
61 BOOST_STATIC_CONSTANT(bool, is_specialized_bin =
62 !use_default_precision &&
63 limits::radix == 2 && limits::digits > 0
64 );
65
66 BOOST_STATIC_CONSTANT(bool, is_specialized_dec =
67 !use_default_precision &&
68 limits::radix == 10 && limits::digits10 > 0
69 );
70
71 BOOST_STATIC_CONSTANT(std::streamsize, streamsize_max =
72 boost::integer_traits<std::streamsize>::const_max
73 );
74
75 BOOST_STATIC_CONSTANT(unsigned int, precision_dec = limits::digits10 + 1U);
76
77 BOOST_STATIC_ASSERT(!is_specialized_dec ||
78 precision_dec <= streamsize_max + 0UL
79 );
80
81 BOOST_STATIC_CONSTANT(unsigned long, precision_bin =
82 2UL + limits::digits * 30103UL / 100000UL
83 );
84
85 BOOST_STATIC_ASSERT(!is_specialized_bin ||
86 (limits::digits + 0UL < ULONG_MAX / 30103UL &&
87 precision_bin > limits::digits10 + 0UL &&
88 precision_bin <= streamsize_max + 0UL)
89 );
90
91 BOOST_STATIC_CONSTANT(std::streamsize, value =
92 is_specialized_bin ? precision_bin
93 : is_specialized_dec ? precision_dec : 6
94 );
95 };
96 #endif
97
98 template<class T>
lcast_get_precision(T * =0)99 inline std::streamsize lcast_get_precision(T* = 0)
100 {
101 #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
102 return lcast_precision<T>::value;
103 #else // Follow lcast_precision algorithm at run-time:
104
105 #ifdef BOOST_NO_IS_ABSTRACT
106 typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
107 #else
108 typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
109 boost::is_abstract<T>
110 , std::numeric_limits<lcast_abstract_stub>
111 , std::numeric_limits<T>
112 >::type limits;
113 #endif
114
115 bool const use_default_precision =
116 !limits::is_specialized || limits::is_exact;
117
118 if(!use_default_precision)
119 { // Includes all built-in floating-point types, float, double ...
120 // and UDT types for which digits (significand bits) is defined (not zero)
121
122 bool const is_specialized_bin =
123 limits::radix == 2 && limits::digits > 0;
124 bool const is_specialized_dec =
125 limits::radix == 10 && limits::digits10 > 0;
126 std::streamsize const streamsize_max =
127 (boost::integer_traits<std::streamsize>::max)();
128
129 if(is_specialized_bin)
130 { // Floating-point types with
131 // limits::digits defined by the specialization.
132
133 unsigned long const digits = limits::digits;
134 unsigned long const precision = 2UL + digits * 30103UL / 100000UL;
135 // unsigned long is selected because it is at least 32-bits
136 // and thus ULONG_MAX / 30103UL is big enough for all types.
137 BOOST_ASSERT(
138 digits < ULONG_MAX / 30103UL &&
139 precision > limits::digits10 + 0UL &&
140 precision <= streamsize_max + 0UL
141 );
142 return precision;
143 }
144 else if(is_specialized_dec)
145 { // Decimal Floating-point type, most likely a User Defined Type
146 // rather than a real floating-point hardware type.
147 unsigned int const precision = limits::digits10 + 1U;
148 BOOST_ASSERT(precision <= streamsize_max + 0UL);
149 return precision;
150 }
151 }
152
153 // Integral type (for which precision has no effect)
154 // or type T for which limits is NOT specialized,
155 // so assume stream precision remains the default 6 decimal digits.
156 // Warning: if your User-defined Floating-point type T is NOT specialized,
157 // then you may lose accuracy by only using 6 decimal digits.
158 // To avoid this, you need to specialize T with either
159 // radix == 2 and digits == the number of significand bits,
160 // OR
161 // radix = 10 and digits10 == the number of decimal digits.
162
163 return 6;
164 #endif
165 }
166
167 template<class T>
lcast_set_precision(std::ios_base & stream,T *)168 inline void lcast_set_precision(std::ios_base& stream, T*)
169 {
170 stream.precision(lcast_get_precision<T>());
171 }
172
173 template<class Source, class Target>
lcast_set_precision(std::ios_base & stream,Source *,Target *)174 inline void lcast_set_precision(std::ios_base& stream, Source*, Target*)
175 {
176 std::streamsize const s = lcast_get_precision(static_cast<Source*>(0));
177 std::streamsize const t = lcast_get_precision(static_cast<Target*>(0));
178 stream.precision(s > t ? s : t);
179 }
180
181 }}
182
183 #endif // BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
184
185