|
1 // (C) Copyright David Abrahams 2001, Howard Hinnant 2001. |
|
2 // |
|
3 // Distributed under the Boost Software License, Version 1.0. (See |
|
4 // accompanying file LICENSE_1_0.txt or copy at |
|
5 // http://www.boost.org/LICENSE_1_0.txt) |
|
6 // |
|
7 // Template class numeric_traits<Number> -- |
|
8 // |
|
9 // Supplies: |
|
10 // |
|
11 // typedef difference_type -- a type used to represent the difference |
|
12 // between any two values of Number. |
|
13 // |
|
14 // Support: |
|
15 // 1. Not all specializations are supplied |
|
16 // |
|
17 // 2. Use of specializations that are not supplied will cause a |
|
18 // compile-time error |
|
19 // |
|
20 // 3. Users are free to specialize numeric_traits for any type. |
|
21 // |
|
22 // 4. Right now, specializations are only supplied for integer types. |
|
23 // |
|
24 // 5. On implementations which do not supply compile-time constants in |
|
25 // std::numeric_limits<>, only specializations for built-in integer types |
|
26 // are supplied. |
|
27 // |
|
28 // 6. Handling of numbers whose range of representation is at least as |
|
29 // great as boost::intmax_t can cause some differences to be |
|
30 // unrepresentable in difference_type: |
|
31 // |
|
32 // Number difference_type |
|
33 // ------ --------------- |
|
34 // signed Number |
|
35 // unsigned intmax_t |
|
36 // |
|
37 // template <class Number> typename numeric_traits<Number>::difference_type |
|
38 // numeric_distance(Number x, Number y) |
|
39 // computes (y - x), attempting to avoid overflows. |
|
40 // |
|
41 |
|
42 // See http://www.boost.org for most recent version including documentation. |
|
43 |
|
44 // Revision History |
|
45 // 11 Feb 2001 - Use BOOST_STATIC_CONSTANT (David Abrahams) |
|
46 // 11 Feb 2001 - Rolled back ineffective Borland-specific code |
|
47 // (David Abrahams) |
|
48 // 10 Feb 2001 - Rolled in supposed Borland fixes from John Maddock, but |
|
49 // not seeing any improvement yet (David Abrahams) |
|
50 // 06 Feb 2001 - Factored if_true out into boost/detail/select_type.hpp |
|
51 // (David Abrahams) |
|
52 // 23 Jan 2001 - Fixed logic of difference_type selection, which was |
|
53 // completely wack. In the process, added digit_traits<> |
|
54 // to compute the number of digits in intmax_t even when |
|
55 // not supplied by numeric_limits<>. (David Abrahams) |
|
56 // 21 Jan 2001 - Created (David Abrahams) |
|
57 |
|
58 #ifndef BOOST_NUMERIC_TRAITS_HPP_DWA20001901 |
|
59 # define BOOST_NUMERIC_TRAITS_HPP_DWA20001901 |
|
60 |
|
61 # include <boost/config.hpp> |
|
62 # include <boost/cstdint.hpp> |
|
63 # include <boost/static_assert.hpp> |
|
64 # include <boost/type_traits.hpp> |
|
65 # include <boost/detail/select_type.hpp> |
|
66 # include <boost/limits.hpp> |
|
67 |
|
68 namespace boost { namespace detail { |
|
69 |
|
70 // Template class is_signed -- determine whether a numeric type is signed |
|
71 // Requires that T is constructable from the literals -1 and 0. Compile-time |
|
72 // error results if that requirement is not met (and thus signedness is not |
|
73 // likely to have meaning for that type). |
|
74 template <class Number> |
|
75 struct is_signed |
|
76 { |
|
77 #if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || defined(BOOST_MSVC) && BOOST_MSVC <= 1300 |
|
78 BOOST_STATIC_CONSTANT(bool, value = (Number(-1) < Number(0))); |
|
79 #else |
|
80 BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<Number>::is_signed); |
|
81 #endif |
|
82 }; |
|
83 |
|
84 # ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS |
|
85 // digit_traits - compute the number of digits in a built-in integer |
|
86 // type. Needed for implementations on which numeric_limits is not specialized |
|
87 // for intmax_t (e.g. VC6). |
|
88 template <bool is_specialized> struct digit_traits_select; |
|
89 |
|
90 // numeric_limits is specialized; just select that version of digits |
|
91 template <> struct digit_traits_select<true> |
|
92 { |
|
93 template <class T> struct traits |
|
94 { |
|
95 BOOST_STATIC_CONSTANT(int, digits = std::numeric_limits<T>::digits); |
|
96 }; |
|
97 }; |
|
98 |
|
99 // numeric_limits is not specialized; compute digits from sizeof(T) |
|
100 template <> struct digit_traits_select<false> |
|
101 { |
|
102 template <class T> struct traits |
|
103 { |
|
104 BOOST_STATIC_CONSTANT(int, digits = ( |
|
105 sizeof(T) * std::numeric_limits<unsigned char>::digits |
|
106 - (is_signed<T>::value ? 1 : 0)) |
|
107 ); |
|
108 }; |
|
109 }; |
|
110 |
|
111 // here's the "usable" template |
|
112 template <class T> struct digit_traits |
|
113 { |
|
114 typedef digit_traits_select< |
|
115 ::std::numeric_limits<T>::is_specialized> selector; |
|
116 typedef typename selector::template traits<T> traits; |
|
117 BOOST_STATIC_CONSTANT(int, digits = traits::digits); |
|
118 }; |
|
119 #endif |
|
120 |
|
121 // Template class integer_traits<Integer> -- traits of various integer types |
|
122 // This should probably be rolled into boost::integer_traits one day, but I |
|
123 // need it to work without <limits> |
|
124 template <class Integer> |
|
125 struct integer_traits |
|
126 { |
|
127 # ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS |
|
128 private: |
|
129 typedef Integer integer_type; |
|
130 typedef std::numeric_limits<integer_type> x; |
|
131 # if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 |
|
132 // for some reason, MSVC asserts when it shouldn't unless we make these |
|
133 // local definitions |
|
134 BOOST_STATIC_CONSTANT(bool, is_integer = x::is_integer); |
|
135 BOOST_STATIC_CONSTANT(bool, is_specialized = x::is_specialized); |
|
136 |
|
137 BOOST_STATIC_ASSERT(is_integer); |
|
138 BOOST_STATIC_ASSERT(is_specialized); |
|
139 # endif |
|
140 public: |
|
141 typedef typename |
|
142 if_true<(int(x::is_signed) |
|
143 && (!int(x::is_bounded) |
|
144 // digits is the number of no-sign bits |
|
145 || (int(x::digits) + 1 >= digit_traits<boost::intmax_t>::digits)))>::template then< |
|
146 Integer, |
|
147 |
|
148 typename if_true<(int(x::digits) + 1 < digit_traits<signed int>::digits)>::template then< |
|
149 signed int, |
|
150 |
|
151 typename if_true<(int(x::digits) + 1 < digit_traits<signed long>::digits)>::template then< |
|
152 signed long, |
|
153 |
|
154 // else |
|
155 intmax_t |
|
156 >::type>::type>::type difference_type; |
|
157 #else |
|
158 BOOST_STATIC_ASSERT(boost::is_integral<Integer>::value); |
|
159 |
|
160 typedef typename |
|
161 if_true<(sizeof(Integer) >= sizeof(intmax_t))>::template then< |
|
162 |
|
163 typename if_true<(is_signed<Integer>::value)>::template then< |
|
164 Integer, |
|
165 intmax_t |
|
166 >::type, |
|
167 |
|
168 typename if_true<(sizeof(Integer) < sizeof(std::ptrdiff_t))>::template then< |
|
169 std::ptrdiff_t, |
|
170 intmax_t |
|
171 >::type |
|
172 >::type difference_type; |
|
173 # endif |
|
174 }; |
|
175 |
|
176 // Right now, only supports integers, but should be expanded. |
|
177 template <class Number> |
|
178 struct numeric_traits |
|
179 { |
|
180 typedef typename integer_traits<Number>::difference_type difference_type; |
|
181 }; |
|
182 |
|
183 template <class Number> |
|
184 typename numeric_traits<Number>::difference_type numeric_distance(Number x, Number y) |
|
185 { |
|
186 typedef typename numeric_traits<Number>::difference_type difference_type; |
|
187 return difference_type(y) - difference_type(x); |
|
188 } |
|
189 }} |
|
190 |
|
191 #endif // BOOST_NUMERIC_TRAITS_HPP_DWA20001901 |