Merge c:/dyninst/pc_bluegene/dyninst into dyn_pc_integration
[dyninst.git] / external / boost / detail / numeric_traits.hpp
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