← Back to branch summary

~ubuntu-branches/ubuntu/wily/bombono-dvd/wily

« back to all changes in this revision

Viewing changes to libs/boost-lib/boost/detail/numeric_traits.hpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2010-11-04 11:46:25 UTC
  • mto: This revision was merged to the branch mainline in revision 8.
  • Revision ID: james.westby@ubuntu.com-20101104114625-8xfdhvhpsm51i0nu
Tags: upstream-0.8.0
Import upstream version 0.8.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
libs/boost-lib/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