integer.hpp
Go to the documentation of this file.
1 // boost integer.hpp header file -------------------------------------------//
2 
3 // Copyright Beman Dawes and Daryle Walker 1999. Distributed under the Boost
4 // Software License, Version 1.0. (See accompanying file
5 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6 
7 // See http://www.boost.org/libs/integer for documentation.
8 
9 // Revision History
10 // 22 Sep 01 Added value-based integer templates. (Daryle Walker)
11 // 01 Apr 01 Modified to use new <boost/limits.hpp> header. (John Maddock)
12 // 30 Jul 00 Add typename syntax fix (Jens Maurer)
13 // 28 Aug 99 Initial version
14 
15 #ifndef BOOST_INTEGER_HPP
16 #define BOOST_INTEGER_HPP
17 
18 #include <boost/integer_fwd.hpp> // self include
19 
20 #include <boost/integer_traits.hpp> // for boost::::boost::integer_traits
21 #include <boost/limits.hpp> // for ::std::numeric_limits
22 #include <boost/cstdint.hpp> // for boost::int64_t and BOOST_NO_INTEGRAL_INT64_T
23 #include <boost/static_assert.hpp>
24 
25 //
26 // We simply cannot include this header on gcc without getting copious warnings of the kind:
27 //
28 // boost/integer.hpp:77:30: warning: use of C99 long long integer constant
29 //
30 // And yet there is no other reasonable implementation, so we declare this a system header
31 // to suppress these warnings.
32 //
33 #if defined(__GNUC__) && (__GNUC__ >= 4)
34 #pragma GCC system_header
35 #endif
36 
37 namespace boost
38 {
39 
40  // Helper templates ------------------------------------------------------//
41 
42  // fast integers from least integers
43  // int_fast_t<> works correctly for unsigned too, in spite of the name.
44  template< typename LeastInt >
45  struct int_fast_t
46  {
47  typedef LeastInt fast;
48  typedef fast type;
49  }; // imps may specialize
50 
51  namespace detail{
52 
53  // convert category to type
54  template< int Category > struct int_least_helper {}; // default is empty
55  template< int Category > struct uint_least_helper {}; // default is empty
56 
57  // specializatons: 1=long, 2=int, 3=short, 4=signed char,
58  // 6=unsigned long, 7=unsigned int, 8=unsigned short, 9=unsigned char
59  // no specializations for 0 and 5: requests for a type > long are in error
60 #ifdef BOOST_HAS_LONG_LONG
61  template<> struct int_least_helper<1> { typedef boost::long_long_type least; };
62 #elif defined(BOOST_HAS_MS_INT64)
63  template<> struct int_least_helper<1> { typedef __int64 least; };
64 #endif
65  template<> struct int_least_helper<2> { typedef long least; };
66  template<> struct int_least_helper<3> { typedef int least; };
67  template<> struct int_least_helper<4> { typedef short least; };
68  template<> struct int_least_helper<5> { typedef signed char least; };
69 #ifdef BOOST_HAS_LONG_LONG
70  template<> struct uint_least_helper<1> { typedef boost::ulong_long_type least; };
71 #elif defined(BOOST_HAS_MS_INT64)
72  template<> struct uint_least_helper<1> { typedef unsigned __int64 least; };
73 #endif
74  template<> struct uint_least_helper<2> { typedef unsigned long least; };
75  template<> struct uint_least_helper<3> { typedef unsigned int least; };
76  template<> struct uint_least_helper<4> { typedef unsigned short least; };
77  template<> struct uint_least_helper<5> { typedef unsigned char least; };
78 
79  template <int Bits>
81  template <int Bits>
83 
84  template <> struct exact_signed_base_helper<sizeof(signed char)* CHAR_BIT> { typedef signed char exact; };
85  template <> struct exact_unsigned_base_helper<sizeof(unsigned char)* CHAR_BIT> { typedef unsigned char exact; };
86 #if USHRT_MAX != UCHAR_MAX
87  template <> struct exact_signed_base_helper<sizeof(short)* CHAR_BIT> { typedef short exact; };
88  template <> struct exact_unsigned_base_helper<sizeof(unsigned short)* CHAR_BIT> { typedef unsigned short exact; };
89 #endif
90 #if UINT_MAX != USHRT_MAX
91  template <> struct exact_signed_base_helper<sizeof(int)* CHAR_BIT> { typedef int exact; };
92  template <> struct exact_unsigned_base_helper<sizeof(unsigned int)* CHAR_BIT> { typedef unsigned int exact; };
93 #endif
94 #if ULONG_MAX != UINT_MAX && ( !defined __TI_COMPILER_VERSION__ || \
95  ( __TI_COMPILER_VERSION__ >= 7000000 && !defined __TI_40BIT_LONG__ ) )
96  template <> struct exact_signed_base_helper<sizeof(long)* CHAR_BIT> { typedef long exact; };
97  template <> struct exact_unsigned_base_helper<sizeof(unsigned long)* CHAR_BIT> { typedef unsigned long exact; };
98 #endif
99 #if defined(BOOST_HAS_LONG_LONG) &&\
100  ((defined(ULLONG_MAX) && (ULLONG_MAX != ULONG_MAX)) ||\
101  (defined(ULONG_LONG_MAX) && (ULONG_LONG_MAX != ULONG_MAX)) ||\
102  (defined(ULONGLONG_MAX) && (ULONGLONG_MAX != ULONG_MAX)) ||\
103  (defined(_ULLONG_MAX) && (_ULLONG_MAX != ULONG_MAX)))
104  template <> struct exact_signed_base_helper<sizeof(boost::long_long_type)* CHAR_BIT> { typedef boost::long_long_type exact; };
105  template <> struct exact_unsigned_base_helper<sizeof(boost::ulong_long_type)* CHAR_BIT> { typedef boost::ulong_long_type exact; };
106 #endif
107 
108 
109  } // namespace detail
110 
111  // integer templates specifying number of bits ---------------------------//
112 
113  // signed
114  template< int Bits > // bits (including sign) required
116  {
117  BOOST_STATIC_ASSERT_MSG(Bits <= (int)(sizeof(boost::intmax_t) * CHAR_BIT),
118  "No suitable signed integer type with the requested number of bits is available.");
119  typedef typename boost::detail::int_least_helper
120  <
121 #ifdef BOOST_HAS_LONG_LONG
122  (Bits <= (int)(sizeof(boost::long_long_type) * CHAR_BIT)) +
123 #else
124  1 +
125 #endif
126  (Bits-1 <= ::std::numeric_limits<long>::digits) +
127  (Bits-1 <= ::std::numeric_limits<int>::digits) +
128  (Bits-1 <= ::std::numeric_limits<short>::digits) +
129  (Bits-1 <= ::std::numeric_limits<signed char>::digits)
131  typedef typename int_fast_t<least>::type fast;
132  };
133 
134  // unsigned
135  template< int Bits > // bits required
137  {
138  BOOST_STATIC_ASSERT_MSG(Bits <= (int)(sizeof(boost::uintmax_t) * CHAR_BIT),
139  "No suitable unsigned integer type with the requested number of bits is available.");
140 #if (defined(__BORLANDC__) || defined(__CODEGEAR__)) && defined(BOOST_NO_INTEGRAL_INT64_T)
141  // It's really not clear why this workaround should be needed... shrug I guess! JM
142  BOOST_STATIC_CONSTANT(int, s =
143  6 +
144  (Bits <= ::std::numeric_limits<unsigned long>::digits) +
145  (Bits <= ::std::numeric_limits<unsigned int>::digits) +
146  (Bits <= ::std::numeric_limits<unsigned short>::digits) +
147  (Bits <= ::std::numeric_limits<unsigned char>::digits));
149 #else
150  typedef typename boost::detail::uint_least_helper
151  <
152 #ifdef BOOST_HAS_LONG_LONG
153  (Bits <= (int)(sizeof(boost::long_long_type) * CHAR_BIT)) +
154 #else
155  1 +
156 #endif
157  (Bits <= ::std::numeric_limits<unsigned long>::digits) +
158  (Bits <= ::std::numeric_limits<unsigned int>::digits) +
159  (Bits <= ::std::numeric_limits<unsigned short>::digits) +
160  (Bits <= ::std::numeric_limits<unsigned char>::digits)
162 #endif
163  typedef typename int_fast_t<least>::type fast;
164  // int_fast_t<> works correctly for unsigned too, in spite of the name.
165  };
166 
167  // integer templates specifying extreme value ----------------------------//
168 
169  // signed
170 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
171  template< boost::long_long_type MaxValue > // maximum value to require support
172 #else
173  template< long MaxValue > // maximum value to require support
174 #endif
176  {
177  typedef typename boost::detail::int_least_helper
178  <
179 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
180  (MaxValue <= ::boost::integer_traits<boost::long_long_type>::const_max) +
181 #else
182  1 +
183 #endif
185  (MaxValue <= ::boost::integer_traits<int>::const_max) +
187  (MaxValue <= ::boost::integer_traits<signed char>::const_max)
189  typedef typename int_fast_t<least>::type fast;
190  };
191 
192 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
193  template< boost::long_long_type MinValue > // minimum value to require support
194 #else
195  template< long MinValue > // minimum value to require support
196 #endif
198  {
199  typedef typename boost::detail::int_least_helper
200  <
201 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
203 #else
204  1 +
205 #endif
211  typedef typename int_fast_t<least>::type fast;
212  };
213 
214  // unsigned
215 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
216  template< boost::ulong_long_type MaxValue > // minimum value to require support
217 #else
218  template< unsigned long MaxValue > // minimum value to require support
219 #endif
221  {
222 #if (defined(__BORLANDC__) || defined(__CODEGEAR__))
223  // It's really not clear why this workaround should be needed... shrug I guess! JM
224 #if defined(BOOST_NO_INTEGRAL_INT64_T)
225  BOOST_STATIC_CONSTANT(unsigned, which =
226  1 +
232 #else // BOOST_NO_INTEGRAL_INT64_T
233  BOOST_STATIC_CONSTANT(unsigned, which =
234  1 +
241 #endif // BOOST_NO_INTEGRAL_INT64_T
242 #else
243  typedef typename boost::detail::uint_least_helper
244  <
245 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
246  (MaxValue <= ::boost::integer_traits<boost::ulong_long_type>::const_max) +
247 #else
248  1 +
249 #endif
251  (MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
253  (MaxValue <= ::boost::integer_traits<unsigned char>::const_max)
254  >::least least;
255 #endif
256  typedef typename int_fast_t<least>::type fast;
257  };
258 
259 
260 } // namespace boost
261 
262 #endif // BOOST_INTEGER_HPP
BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE.
int64_t intmax_t
Definition: stdint.h:123
GLdouble s
boost::detail::int_least_helper< 1+(Bits-1<=::std::numeric_limits< long >::digits)+(Bits-1<=::std::numeric_limits< int >::digits)+(Bits-1<=::std::numeric_limits< short >::digits)+(Bits-1<=::std::numeric_limits< signed char >::digits) >::least least
Definition: integer.hpp:130
boost::detail::int_least_helper< 1+(MinValue >=::boost::integer_traits< long >::const_min)+(MinValue >=::boost::integer_traits< int >::const_min)+(MinValue >=::boost::integer_traits< short >::const_min)+(MinValue >=::boost::integer_traits< signed char >::const_min) >::least least
Definition: integer.hpp:210
boost::detail::uint_least_helper< 1+(Bits<=::std::numeric_limits< unsigned long >::digits)+(Bits<=::std::numeric_limits< unsigned int >::digits)+(Bits<=::std::numeric_limits< unsigned short >::digits)+(Bits<=::std::numeric_limits< unsigned char >::digits) >::least least
Definition: integer.hpp:161
int_fast_t< least >::type fast
Definition: integer.hpp:163
LeastInt fast
Definition: integer.hpp:47
int_fast_t< least >::type fast
Definition: integer.hpp:211
const char * detail
int_fast_t< least >::type fast
Definition: integer.hpp:256
uint64_t uintmax_t
Definition: stdint.h:124
#define BOOST_STATIC_ASSERT_MSG(...)
int_fast_t< least >::type fast
Definition: integer.hpp:131
#define BOOST_STATIC_CONSTANT(type, assignment)
Definition: suffix.hpp:394
int_fast_t< least >::type fast
Definition: integer.hpp:189


librealsense2
Author(s): Sergey Dorodnicov , Doron Hirshberg , Mark Horn , Reagan Lopez , Itay Carpis
autogenerated on Mon May 3 2021 02:47:17