BVB Source Codes

mars Show integer.hpp Source code

Return Download mars: download integer.hpp Source code - Download mars Source code - Type:.hpp
  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 mars_boost::::mars_boost::integer_traits
  21. #include <boost/limits.hpp>          // for ::std::numeric_limits
  22. #include <boost/cstdint.hpp>         // for mars_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 mars_boost {} namespace boost = mars_boost; namespace mars_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 mars_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 mars_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>
  80.   struct exact_signed_base_helper{};
  81.   template <int Bits>
  82.   struct exact_unsigned_base_helper{};
  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(mars_boost::long_long_type)* CHAR_BIT> { typedef mars_boost::long_long_type exact; };
  105.   template <> struct exact_unsigned_base_helper<sizeof(mars_boost::ulong_long_type)* CHAR_BIT> { typedef mars_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
  115.   struct int_t : public mars_boost::detail::exact_signed_base_helper<Bits>
  116.   {
  117.       BOOST_STATIC_ASSERT_MSG(Bits <= (int)(sizeof(mars_boost::intmax_t) * CHAR_BIT),
  118.          "No suitable signed integer type with the requested number of bits is available.");
  119.       typedef typename mars_boost::detail::int_least_helper
  120.         <
  121. #ifdef BOOST_HAS_LONG_LONG
  122.           (Bits <= (int)(sizeof(mars_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)
  130.         >::least  least;
  131.       typedef typename int_fast_t<least>::type  fast;
  132.   };
  133.  
  134.   //  unsigned
  135.   template< int Bits >   // bits required
  136.   struct uint_t : public mars_boost::detail::exact_unsigned_base_helper<Bits>
  137.   {
  138.      BOOST_STATIC_ASSERT_MSG(Bits <= (int)(sizeof(mars_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));
  148.      typedef typename detail::int_least_helper< ::mars_boost::uint_t<Bits>::s>::least least;
  149. #else
  150.       typedef typename mars_boost::detail::uint_least_helper
  151.         <
  152. #ifdef BOOST_HAS_LONG_LONG
  153.           (Bits <= (int)(sizeof(mars_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)
  161.         >::least  least;
  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< mars_boost::long_long_type MaxValue >   // maximum value to require support
  172. #else
  173.   template< long MaxValue >   // maximum value to require support
  174. #endif
  175.   struct int_max_value_t
  176.   {
  177.       typedef typename mars_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 <= ::mars_boost::integer_traits<mars_boost::long_long_type>::const_max) +
  181. #else
  182.            1 +
  183. #endif
  184.           (MaxValue <= ::mars_boost::integer_traits<long>::const_max) +
  185.           (MaxValue <= ::mars_boost::integer_traits<int>::const_max) +
  186.           (MaxValue <= ::mars_boost::integer_traits<short>::const_max) +
  187.           (MaxValue <= ::mars_boost::integer_traits<signed char>::const_max)
  188.         >::least  least;
  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< mars_boost::long_long_type MinValue >   // minimum value to require support
  194. #else
  195.   template< long MinValue >   // minimum value to require support
  196. #endif
  197.   struct int_min_value_t
  198.   {
  199.       typedef typename mars_boost::detail::int_least_helper
  200.         <
  201. #if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
  202.           (MinValue >= ::mars_boost::integer_traits<mars_boost::long_long_type>::const_min) +
  203. #else
  204.            1 +
  205. #endif
  206.           (MinValue >= ::mars_boost::integer_traits<long>::const_min) +
  207.           (MinValue >= ::mars_boost::integer_traits<int>::const_min) +
  208.           (MinValue >= ::mars_boost::integer_traits<short>::const_min) +
  209.           (MinValue >= ::mars_boost::integer_traits<signed char>::const_min)
  210.         >::least  least;
  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< mars_boost::ulong_long_type MaxValue >   // minimum value to require support
  217. #else
  218.   template< unsigned long MaxValue >   // minimum value to require support
  219. #endif
  220.   struct uint_value_t
  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 +
  227.           (MaxValue <= ::mars_boost::integer_traits<unsigned long>::const_max) +
  228.           (MaxValue <= ::mars_boost::integer_traits<unsigned int>::const_max) +
  229.           (MaxValue <= ::mars_boost::integer_traits<unsigned short>::const_max) +
  230.           (MaxValue <= ::mars_boost::integer_traits<unsigned char>::const_max));
  231.       typedef typename detail::int_least_helper< ::mars_boost::uint_value_t<MaxValue>::which>::least least;
  232. #else // BOOST_NO_INTEGRAL_INT64_T
  233.       BOOST_STATIC_CONSTANT(unsigned, which =
  234.            1 +
  235.           (MaxValue <= ::mars_boost::integer_traits<mars_boost::ulong_long_type>::const_max) +
  236.           (MaxValue <= ::mars_boost::integer_traits<unsigned long>::const_max) +
  237.           (MaxValue <= ::mars_boost::integer_traits<unsigned int>::const_max) +
  238.           (MaxValue <= ::mars_boost::integer_traits<unsigned short>::const_max) +
  239.           (MaxValue <= ::mars_boost::integer_traits<unsigned char>::const_max));
  240.       typedef typename detail::uint_least_helper< ::mars_boost::uint_value_t<MaxValue>::which>::least least;
  241. #endif // BOOST_NO_INTEGRAL_INT64_T
  242. #else
  243.       typedef typename mars_boost::detail::uint_least_helper
  244.         <
  245. #if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
  246.           (MaxValue <= ::mars_boost::integer_traits<mars_boost::ulong_long_type>::const_max) +
  247. #else
  248.            1 +
  249. #endif
  250.           (MaxValue <= ::mars_boost::integer_traits<unsigned long>::const_max) +
  251.           (MaxValue <= ::mars_boost::integer_traits<unsigned int>::const_max) +
  252.           (MaxValue <= ::mars_boost::integer_traits<unsigned short>::const_max) +
  253.           (MaxValue <= ::mars_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 mars_boost
  261.  
  262. #endif  // BOOST_INTEGER_HPP
  263.  
downloadinteger.hpp Source code - Download mars Source code
Related Source Codes/Software:
Hero - Elegant transition library for iOS & tvOS 2017-06-09
deep-photo-styletransfer - Code and data for paper "Deep Photo Style Transfer... 2017-06-09
mastodon - A GNU Social-compatible microblogging server ... 2017-06-09
plyr - A simple HTML5, YouTube and Vimeo player ... 2017-06-08
prepack - Prepack is a partial evaluator for JavaScript. Pre... 2017-06-08
Public-APIs - 2017-06-09
lottie-ios - An iOS library to natively render After Effects ve... 2017-06-09
Awesome-Hacking - A collection of various awesome lists for hackers,... 2017-06-09
algorithms - Minimal examples of data structures and algorithms... 2017-06-10
lectures - Oxford Deep NLP 2017 course 2017-06-10
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top