forked from boostorg/integer
Reverted Integer back to Release branch state - as per devel-list discussions.
[SVN r57580]
This commit is contained in:
John Maddock
@ -7,12 +7,6 @@
|
||||
// See http://www.boost.org/libs/integer for documentation.
|
||||
|
||||
// Revision History
|
||||
// 16 Jul 08 Added MPL-compatible variants of the minimum-size and value-
|
||||
// based integer templates. (Daryle Walker)
|
||||
// 15 Jul 08 Added exact-integer templates; added MPL-compatible variant of
|
||||
// processor-optimized integer template. (Daryle Walker)
|
||||
// 14 Jul 08 Added extended-integer support. (Daryle Walker)
|
||||
// 13 Jul 08 Redid implmentation. (Daryle Walker)
|
||||
// 22 Sep 01 Added value-based integer templates. (Daryle Walker)
|
||||
// 01 Apr 01 Modified to use new <boost/limits.hpp> header. (John Maddock)
|
||||
// 30 Jul 00 Add typename syntax fix (Jens Maurer)
|
||||
@ -23,357 +17,108 @@
|
||||
|
||||
#include <boost/integer_fwd.hpp> // self include
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_STATIC_CONSTANT, etc.
|
||||
#include <boost/cstdint.hpp> // for boost::uintmax_t, intmax_t
|
||||
#include <boost/integer_traits.hpp> // for boost::integer_traits
|
||||
#include <boost/limits.hpp> // for std::numeric_limits
|
||||
#include <boost/utility/enable_if.hpp> // for boost::enable_if_c
|
||||
|
||||
#include <boost/detail/extended_integer.hpp> // for BOOST_HAS_XINT, etc.
|
||||
|
||||
#include <climits> // for UCHAR_MAX, USHRT_MAX, UINT_MAX, ULONG_MAX, etc.
|
||||
#include <boost/integer_traits.hpp> // for boost::integer_traits
|
||||
#include <boost/limits.hpp> // for std::numeric_limits
|
||||
|
||||
namespace boost
|
||||
{
|
||||
|
||||
// integer template mapping a type to its processor-optimized analog -----//
|
||||
|
||||
// Some types can be handled better by the processor than others. This
|
||||
// template metafunction should map various built-in integral types to
|
||||
// the processor's perferred type for the given type's value range
|
||||
template < typename BaseInt >
|
||||
struct fast_integral
|
||||
{
|
||||
typedef BaseInt type;
|
||||
};
|
||||
|
||||
// Platform-specific specializations should go here.
|
||||
// Helper templates ------------------------------------------------------//
|
||||
|
||||
// fast integers from least integers
|
||||
// int_fast_t<> works correctly for unsigned too, in spite of the name.
|
||||
template< typename LeastInt >
|
||||
struct int_fast_t { typedef typename fast_integral<LeastInt>::type fast; };
|
||||
struct int_fast_t { typedef LeastInt fast; }; // imps may specialize
|
||||
|
||||
namespace detail
|
||||
{
|
||||
// convert category to type
|
||||
template< int Category > struct int_least_helper {}; // default is empty
|
||||
|
||||
// Helper templates ------------------------------------------------------//
|
||||
|
||||
// convert integer category to type ; default is empty
|
||||
template< int Rank, typename Signedness > struct int_least_helper {};
|
||||
|
||||
// specializatons: 1=(unsigned) __int64/long long, 2=(unsigned) long,
|
||||
// 3=unsigned/int, 4=(unsigned) short, 5=(un)signed char
|
||||
// no specializations for 0: requests for a type > (unsigned) (long) long are
|
||||
// in error
|
||||
#if BOOST_HAS_XINT
|
||||
template<> struct int_least_helper<1, signed> { typedef xint_t least; };
|
||||
template<> struct int_least_helper<1, unsigned> { typedef uxint_t least; };
|
||||
#endif
|
||||
template<> struct int_least_helper<2, signed> { typedef long least; };
|
||||
template<> struct int_least_helper<2, unsigned>
|
||||
{ typedef unsigned long least; };
|
||||
template<> struct int_least_helper<3, signed> { typedef int least; };
|
||||
template<> struct int_least_helper<3, unsigned>
|
||||
{ typedef unsigned int least; };
|
||||
template<> struct int_least_helper<4, signed> { typedef short least; };
|
||||
template<> struct int_least_helper<4, unsigned>
|
||||
{ typedef unsigned short least; };
|
||||
template<> struct int_least_helper<5, signed> { typedef signed char least; };
|
||||
template<> struct int_least_helper<5, unsigned>
|
||||
{ typedef unsigned char least; };
|
||||
|
||||
// category bounds
|
||||
enum
|
||||
{
|
||||
#if BOOST_HAS_XINT
|
||||
lowest_integral_rank = 1,
|
||||
#else
|
||||
lowest_integral_rank = 2,
|
||||
#endif
|
||||
highest_integral_rank = 5
|
||||
};
|
||||
|
||||
// map a bit count to a category
|
||||
template < int BitsIncludingSign >
|
||||
struct int_rank_helper
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( int, mantissa = BitsIncludingSign - 1 );
|
||||
#if BOOST_HAS_XINT
|
||||
BOOST_STATIC_CONSTANT( int, extended_ = (mantissa <= std::numeric_limits<
|
||||
xint_t >::digits) );
|
||||
#else
|
||||
BOOST_STATIC_CONSTANT( int, extended_ = 1 );
|
||||
#endif
|
||||
BOOST_STATIC_CONSTANT( int, rank = (BitsIncludingSign > 0) * (extended_ +
|
||||
(mantissa <= std::numeric_limits< long >::digits) +
|
||||
(mantissa <= std::numeric_limits< int >::digits) +
|
||||
(mantissa <= std::numeric_limits< short >::digits) +
|
||||
(mantissa <= std::numeric_limits< signed char >::digits)) );
|
||||
};
|
||||
|
||||
template < int Bits >
|
||||
struct uint_rank_helper
|
||||
{
|
||||
#if BOOST_HAS_XINT
|
||||
BOOST_STATIC_CONSTANT( int, extended_ = (Bits <= std::numeric_limits<
|
||||
uxint_t >::digits) );
|
||||
#else
|
||||
BOOST_STATIC_CONSTANT( int, extended_ = 1 );
|
||||
#endif
|
||||
BOOST_STATIC_CONSTANT( int, rank = (Bits >= 0) * (extended_ +
|
||||
(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)) );
|
||||
};
|
||||
|
||||
template < int BitsIncludingSign >
|
||||
struct int_exact_rank_helper { BOOST_STATIC_CONSTANT( int, rank = 0 ); };
|
||||
template < int Bits >
|
||||
struct uint_exact_rank_helper { BOOST_STATIC_CONSTANT( int, rank = 0 ); };
|
||||
|
||||
#define BOOST_PRIVATE_INT_EXACT_BUILDER(Type, Rank) \
|
||||
template < > \
|
||||
struct int_exact_rank_helper<std::numeric_limits< Type >::digits + 1> \
|
||||
{ BOOST_STATIC_CONSTANT( int, rank = Rank ); }
|
||||
#define BOOST_PRIVATE_UINT_EXACT_BUILDER(Type, Rank) \
|
||||
template < > \
|
||||
struct uint_exact_rank_helper<std::numeric_limits< Type >::digits> \
|
||||
{ BOOST_STATIC_CONSTANT( int, rank = Rank ); }
|
||||
|
||||
#if BOOST_HAS_XINT && (BOOST_UXINT_MAX > ULONG_MAX)
|
||||
BOOST_PRIVATE_INT_EXACT_BUILDER( xint_t, 1 );
|
||||
BOOST_PRIVATE_UINT_EXACT_BUILDER( uxint_t, 1 );
|
||||
#endif
|
||||
#if ULONG_MAX > UINT_MAX
|
||||
BOOST_PRIVATE_INT_EXACT_BUILDER( long, 2 );
|
||||
BOOST_PRIVATE_UINT_EXACT_BUILDER( unsigned long, 2 );
|
||||
#endif
|
||||
#if UINT_MAX > USHRT_MAX
|
||||
BOOST_PRIVATE_INT_EXACT_BUILDER( int, 3 );
|
||||
BOOST_PRIVATE_UINT_EXACT_BUILDER( unsigned, 3 );
|
||||
#endif
|
||||
#if USHRT_MAX > UCHAR_MAX
|
||||
BOOST_PRIVATE_INT_EXACT_BUILDER( short, 4 );
|
||||
BOOST_PRIVATE_UINT_EXACT_BUILDER( unsigned short, 4 );
|
||||
#endif
|
||||
BOOST_PRIVATE_INT_EXACT_BUILDER( signed char, 5 );
|
||||
BOOST_PRIVATE_UINT_EXACT_BUILDER( unsigned char, 5 );
|
||||
|
||||
#undef BOOST_PRIVATE_INT_EXACT_BUILDER
|
||||
#undef BOOST_PRIVATE_UINT_EXACT_BUILDER
|
||||
|
||||
// map an extreme value to a category
|
||||
template < intmax_t MaxValue >
|
||||
struct int_max_rank_helper
|
||||
{
|
||||
#if BOOST_HAS_XINT
|
||||
BOOST_STATIC_CONSTANT( int, extended_ = (MaxValue <=
|
||||
boost::integer_traits< xint_t >::const_max) );
|
||||
#else
|
||||
BOOST_STATIC_CONSTANT( int, extended_ = 1 );
|
||||
#endif
|
||||
BOOST_STATIC_CONSTANT( int, rank = (MaxValue > 0) * (extended_ +
|
||||
(MaxValue <= boost::integer_traits< long >::const_max) +
|
||||
(MaxValue <= boost::integer_traits< int >::const_max) +
|
||||
(MaxValue <= boost::integer_traits< short >::const_max) +
|
||||
(MaxValue <= boost::integer_traits< signed char >::const_max)) );
|
||||
};
|
||||
|
||||
template < intmax_t MinValue >
|
||||
struct int_min_rank_helper
|
||||
{
|
||||
#if BOOST_HAS_XINT
|
||||
BOOST_STATIC_CONSTANT( int, extended_ = (MinValue >=
|
||||
boost::integer_traits< xint_t >::const_min) );
|
||||
#else
|
||||
BOOST_STATIC_CONSTANT( int, extended_ = 1 );
|
||||
#endif
|
||||
BOOST_STATIC_CONSTANT( int, rank = (MinValue < 0) * (extended_ +
|
||||
(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)) );
|
||||
};
|
||||
|
||||
template < uintmax_t Value >
|
||||
struct uint_max_rank_helper
|
||||
{
|
||||
#if BOOST_HAS_XINT
|
||||
BOOST_STATIC_CONSTANT( int, extended_ = (Value <= boost::integer_traits<
|
||||
uxint_t >::const_max) );
|
||||
#else
|
||||
BOOST_STATIC_CONSTANT( int, extended_ = 1 );
|
||||
#endif
|
||||
BOOST_STATIC_CONSTANT( int, rank = extended_ +
|
||||
(Value <= boost::integer_traits< unsigned long >::const_max) +
|
||||
(Value <= boost::integer_traits< unsigned int >::const_max) +
|
||||
(Value <= boost::integer_traits< unsigned short >::const_max) +
|
||||
(Value <= boost::integer_traits< unsigned char >::const_max) );
|
||||
};
|
||||
|
||||
// convert rank to type, Boost.MPL-style
|
||||
template < int Rank, typename Signedness, class Enable = void >
|
||||
struct integral_rank_to_type
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( bool, is_specialized = false );
|
||||
// No "signed" nor "type" here
|
||||
};
|
||||
|
||||
template < int Rank >
|
||||
struct integral_rank_to_type< Rank, signed, typename
|
||||
enable_if_c<(lowest_integral_rank <= Rank) && (Rank <=
|
||||
highest_integral_rank)>::type >
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( bool, is_specialized = true );
|
||||
BOOST_STATIC_CONSTANT( bool, is_signed = true );
|
||||
typedef typename int_least_helper< Rank, signed >::least type;
|
||||
};
|
||||
|
||||
template < int Rank >
|
||||
struct integral_rank_to_type< Rank, unsigned, typename
|
||||
enable_if_c<(lowest_integral_rank <= Rank) && (Rank <=
|
||||
highest_integral_rank)>::type >
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( bool, is_specialized = true );
|
||||
BOOST_STATIC_CONSTANT( bool, is_signed = false );
|
||||
typedef typename int_least_helper< Rank, unsigned >::least type;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// MPL-compatible integer-mapping class templates ------------------------//
|
||||
|
||||
// minimum number of bits
|
||||
template < int Bits, typename Signedness >
|
||||
struct sized_integral
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( bool, is_specialized = false );
|
||||
BOOST_STATIC_CONSTANT( int, bit_count = Bits );
|
||||
};
|
||||
|
||||
template < int BitsIncludingSign >
|
||||
struct sized_integral< BitsIncludingSign, signed >
|
||||
: detail::integral_rank_to_type<
|
||||
detail::int_rank_helper<BitsIncludingSign>::rank, signed >
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( int, bit_count = BitsIncludingSign );
|
||||
};
|
||||
|
||||
template < int Bits >
|
||||
struct sized_integral< Bits, unsigned >
|
||||
: detail::integral_rank_to_type<
|
||||
detail::uint_rank_helper<Bits>::rank, unsigned >
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( int, bit_count = Bits );
|
||||
};
|
||||
|
||||
// exact number of bits
|
||||
template < int Bits, typename Signedness >
|
||||
struct exact_integral
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( bool, is_specialized = false );
|
||||
BOOST_STATIC_CONSTANT( int, bit_count = Bits );
|
||||
};
|
||||
|
||||
template < int BitsIncludingSign >
|
||||
struct exact_integral< BitsIncludingSign, signed >
|
||||
: detail::integral_rank_to_type<
|
||||
detail::int_exact_rank_helper<BitsIncludingSign>::rank, signed >
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( int, bit_count = BitsIncludingSign );
|
||||
};
|
||||
|
||||
template < int Bits >
|
||||
struct exact_integral< Bits, unsigned >
|
||||
: detail::integral_rank_to_type<
|
||||
detail::uint_exact_rank_helper<Bits>::rank, unsigned >
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( int, bit_count = Bits );
|
||||
};
|
||||
|
||||
// maximum supported (positive) value, signed
|
||||
template < intmax_t MaxValue >
|
||||
struct maximum_signed_integral
|
||||
: detail::integral_rank_to_type<
|
||||
detail::int_max_rank_helper<MaxValue>::rank, signed >
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( intmax_t, bound = MaxValue );
|
||||
};
|
||||
|
||||
// minimum supported (negative) value
|
||||
template < intmax_t MinValue >
|
||||
struct minimum_signed_integral
|
||||
: detail::integral_rank_to_type<
|
||||
detail::int_min_rank_helper<MinValue>::rank, signed >
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( intmax_t, bound = MinValue );
|
||||
};
|
||||
|
||||
// maximum supported (nonnegative) value, unsigned
|
||||
template < uintmax_t Value >
|
||||
struct maximum_unsigned_integral
|
||||
: detail::integral_rank_to_type<
|
||||
detail::uint_max_rank_helper<Value>::rank, unsigned >
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( uintmax_t, bound = Value );
|
||||
};
|
||||
// specializatons: 1=long, 2=int, 3=short, 4=signed char,
|
||||
// 6=unsigned long, 7=unsigned int, 8=unsigned short, 9=unsigned char
|
||||
// no specializations for 0 and 5: requests for a type > long are in error
|
||||
template<> struct int_least_helper<1> { typedef long least; };
|
||||
template<> struct int_least_helper<2> { typedef int least; };
|
||||
template<> struct int_least_helper<3> { typedef short least; };
|
||||
template<> struct int_least_helper<4> { typedef signed char least; };
|
||||
template<> struct int_least_helper<6> { typedef unsigned long least; };
|
||||
template<> struct int_least_helper<7> { typedef unsigned int least; };
|
||||
template<> struct int_least_helper<8> { typedef unsigned short least; };
|
||||
template<> struct int_least_helper<9> { typedef unsigned char least; };
|
||||
|
||||
// integer templates specifying number of bits ---------------------------//
|
||||
|
||||
// signed
|
||||
template< int Bits > // minimum bits (including sign) required
|
||||
template< int Bits > // bits (including sign) required
|
||||
struct int_t
|
||||
{
|
||||
typedef typename sized_integral<Bits, signed>::type least;
|
||||
typedef typename int_fast_t<least>::fast fast;
|
||||
};
|
||||
|
||||
template< int Bits > // exact bits (including sign) desired
|
||||
struct int_exact_t
|
||||
{
|
||||
typedef typename exact_integral<Bits, signed>::type exact;
|
||||
typedef typename int_least_helper
|
||||
<
|
||||
(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;
|
||||
typedef typename int_fast_t<least>::fast fast;
|
||||
};
|
||||
|
||||
// unsigned
|
||||
template< int Bits > // minimum bits required
|
||||
template< int Bits > // bits required
|
||||
struct uint_t
|
||||
{
|
||||
typedef typename sized_integral<Bits, unsigned>::type least;
|
||||
typedef typename int_fast_t<least>::fast fast;
|
||||
typedef typename int_least_helper
|
||||
<
|
||||
5 +
|
||||
(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;
|
||||
typedef typename int_fast_t<least>::fast fast;
|
||||
// int_fast_t<> works correctly for unsigned too, in spite of the name.
|
||||
};
|
||||
|
||||
template< int Bits > // exact bits desired
|
||||
struct uint_exact_t
|
||||
{
|
||||
typedef typename exact_integral<Bits, unsigned>::type exact;
|
||||
};
|
||||
|
||||
// integer templates specifying extreme value ----------------------------//
|
||||
|
||||
// signed
|
||||
template< intmax_t MaxValue > // maximum value to require support
|
||||
template< long MaxValue > // maximum value to require support
|
||||
struct int_max_value_t
|
||||
{
|
||||
typedef typename maximum_signed_integral<MaxValue>::type least;
|
||||
typedef typename int_fast_t<least>::fast fast;
|
||||
typedef typename int_least_helper
|
||||
<
|
||||
(MaxValue <= integer_traits<long>::const_max) +
|
||||
(MaxValue <= integer_traits<int>::const_max) +
|
||||
(MaxValue <= integer_traits<short>::const_max) +
|
||||
(MaxValue <= integer_traits<signed char>::const_max)
|
||||
>::least least;
|
||||
typedef typename int_fast_t<least>::fast fast;
|
||||
};
|
||||
|
||||
template< intmax_t MinValue > // minimum value to require support
|
||||
template< long MinValue > // minimum value to require support
|
||||
struct int_min_value_t
|
||||
{
|
||||
typedef typename minimum_signed_integral<MinValue>::type least;
|
||||
typedef typename int_fast_t<least>::fast fast;
|
||||
typedef typename int_least_helper
|
||||
<
|
||||
(MinValue >= integer_traits<long>::const_min) +
|
||||
(MinValue >= integer_traits<int>::const_min) +
|
||||
(MinValue >= integer_traits<short>::const_min) +
|
||||
(MinValue >= integer_traits<signed char>::const_min)
|
||||
>::least least;
|
||||
typedef typename int_fast_t<least>::fast fast;
|
||||
};
|
||||
|
||||
// unsigned
|
||||
template< uintmax_t Value > // maximum value to require support
|
||||
template< unsigned long Value > // maximum value to require support
|
||||
struct uint_value_t
|
||||
{
|
||||
typedef typename maximum_unsigned_integral<Value>::type least;
|
||||
typedef typename int_fast_t<least>::fast fast;
|
||||
typedef typename int_least_helper
|
||||
<
|
||||
5 +
|
||||
(Value <= integer_traits<unsigned long>::const_max) +
|
||||
(Value <= integer_traits<unsigned int>::const_max) +
|
||||
(Value <= integer_traits<unsigned short>::const_max) +
|
||||
(Value <= integer_traits<unsigned char>::const_max)
|
||||
>::least least;
|
||||
typedef typename int_fast_t<least>::fast fast;
|
||||
};
|
||||
|
||||
|
||||
|
||||
@ -12,192 +12,81 @@
|
||||
|
||||
#include <boost/integer_fwd.hpp> // self include
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_STATIC_CONSTANT
|
||||
#include <boost/cstdint.hpp> // for boost::uintmax_t
|
||||
#include <boost/integer.hpp> // for boost::sized_integral
|
||||
#include <boost/limits.hpp> // for std::numeric_limits
|
||||
#include <boost/mpl/and.hpp> // for boost::mpl::and_
|
||||
#include <boost/mpl/bitwise.hpp> // for boost::mpl::bitor_, shift_left
|
||||
#include <boost/mpl/bool.hpp> // for boost::mpl::true_
|
||||
#include <boost/mpl/comparison.hpp> // for boost::mpl::greater_equal, etc.
|
||||
#include <boost/mpl/empty_base.hpp> // for boost::mpl::empty_base
|
||||
#include <boost/mpl/if.hpp> // for boost::mpl::if_
|
||||
#include <boost/mpl/int.hpp> // for boost::mpl::int_
|
||||
#include <boost/mpl/integral_c.hpp> // for boost::integral_c
|
||||
#include <boost/mpl/next_prior.hpp> // for boost::mpl::next, prior
|
||||
#include <boost/utility/enable_if.hpp> // for boost::enable_if
|
||||
#include <boost/config.hpp> // for BOOST_STATIC_CONSTANT
|
||||
#include <boost/integer.hpp> // for boost::uint_t
|
||||
|
||||
#include <climits> // for UCHAR_MAX, etc.
|
||||
#include <cstddef> // for std::size_t
|
||||
|
||||
#include <boost/limits.hpp> // for std::numeric_limits
|
||||
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
|
||||
// Helper templates --------------------------------------------------------//
|
||||
|
||||
template < int Bits >
|
||||
struct hi_integer_mask_builder1
|
||||
{
|
||||
typedef boost::mpl::int_<Bits> bit_count_type;
|
||||
|
||||
typedef typename boost::mpl::next<bit_count_type>::type
|
||||
mask_length_type;
|
||||
typedef boost::sized_integral<mask_length_type::value, unsigned>
|
||||
mask_type;
|
||||
|
||||
typedef boost::mpl::integral_c<typename mask_type::type, 1> one_type;
|
||||
typedef boost::mpl::shift_left<one_type, bit_count_type> result_type;
|
||||
};
|
||||
|
||||
template < int Bits >
|
||||
struct hi_integer_mask_builder2
|
||||
{
|
||||
typedef boost::mpl::int_<Bits> bit_count_type;
|
||||
|
||||
typedef boost::mpl::greater_equal< bit_count_type, boost::mpl::int_<0> >
|
||||
lo_bound_type;
|
||||
typedef boost::mpl::less< bit_count_type,
|
||||
boost::mpl::int_<std::numeric_limits<boost::uintmax_t>::digits> >
|
||||
hi_bound_type;
|
||||
typedef boost::mpl::and_<lo_bound_type, hi_bound_type> count_valid_type;
|
||||
};
|
||||
|
||||
template < int Bits, class Enable = void >
|
||||
struct hi_integer_mask_builder3
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( bool, is_specialized = false );
|
||||
};
|
||||
|
||||
template < int Bits >
|
||||
struct hi_integer_mask_builder3< Bits, typename boost::enable_if<typename
|
||||
hi_integer_mask_builder2<Bits>::count_valid_type>::type >
|
||||
: hi_integer_mask_builder1<Bits>::result_type
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( bool, is_specialized = true );
|
||||
};
|
||||
|
||||
template < int Bits >
|
||||
struct lo_integer_mask_builder1
|
||||
{
|
||||
typedef boost::mpl::int_<Bits> bit_count_type;
|
||||
|
||||
typedef typename boost::mpl::prior<bit_count_type>::type
|
||||
shift_length_type;
|
||||
typedef boost::sized_integral<bit_count_type::value, unsigned>
|
||||
mask_type;
|
||||
|
||||
typedef boost::mpl::integral_c<typename mask_type::type, 1> one_type;
|
||||
typedef boost::mpl::shift_left<one_type, shift_length_type>
|
||||
high_bit_type;
|
||||
typedef typename boost::mpl::prior<high_bit_type>::type low_bits_type;
|
||||
typedef boost::mpl::bitor_<high_bit_type, low_bits_type> result_type;
|
||||
};
|
||||
|
||||
template < >
|
||||
struct lo_integer_mask_builder1< 0 >
|
||||
{
|
||||
// Let's not deal with negative interim values....
|
||||
typedef boost::mpl::integral_c<unsigned char, 0u> result_type;
|
||||
};
|
||||
|
||||
template < int Bits >
|
||||
struct lo_integer_mask_builder2
|
||||
{
|
||||
typedef boost::mpl::int_<Bits> bit_count_type;
|
||||
|
||||
typedef boost::mpl::greater_equal< bit_count_type, boost::mpl::int_<0> >
|
||||
lo_bound_type;
|
||||
typedef boost::mpl::less_equal< bit_count_type,
|
||||
boost::mpl::int_<std::numeric_limits<boost::uintmax_t>::digits> >
|
||||
hi_bound_type;
|
||||
typedef boost::mpl::and_<lo_bound_type, hi_bound_type> count_valid_type;
|
||||
};
|
||||
|
||||
template < >
|
||||
struct lo_integer_mask_builder2< 0 >
|
||||
{
|
||||
typedef boost::mpl::true_ count_valid_type;
|
||||
};
|
||||
|
||||
template < int Bits, class Enable = void >
|
||||
struct lo_integer_mask_builder3
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( bool, is_specialized = false );
|
||||
// No MPL Integral Constant to inherit from
|
||||
};
|
||||
|
||||
template < int Bits >
|
||||
struct lo_integer_mask_builder3< Bits, typename enable_if<typename
|
||||
lo_integer_mask_builder2<Bits>::count_valid_type>::type >
|
||||
: lo_integer_mask_builder1<Bits>::result_type
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( bool, is_specialized = true );
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
|
||||
// MPL-compatible integer mask class templates -----------------------------//
|
||||
|
||||
// Displaced single-bit mask, 1 << Offset, 0 <= Offset < BitLengthOf(uintmax_t)
|
||||
template < int Offset >
|
||||
struct integer_hi_mask
|
||||
: detail::hi_integer_mask_builder3<Offset>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( int, bit_offset = Offset );
|
||||
};
|
||||
|
||||
// Lowest bit-group mask, 2**Length - 1, 0 <= Length <= BitLengthOf(uintmax_t)
|
||||
template < int Length >
|
||||
struct integer_lo_mask
|
||||
: detail::lo_integer_mask_builder3<Length>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( int, bit_count = Length );
|
||||
};
|
||||
|
||||
|
||||
// Specified single-bit mask class declaration -----------------------------//
|
||||
// (Lowest bit starts counting at 0.)
|
||||
|
||||
template < std::size_t Bit >
|
||||
class high_bit_mask_t
|
||||
struct high_bit_mask_t
|
||||
{
|
||||
typedef integer_hi_mask<Bit> impl_type;
|
||||
typedef typename uint_t<(Bit + 1)>::least least;
|
||||
typedef typename uint_t<(Bit + 1)>::fast fast;
|
||||
|
||||
public:
|
||||
typedef typename impl_type::value_type least;
|
||||
typedef typename int_fast_t<least>::fast fast;
|
||||
BOOST_STATIC_CONSTANT( least, high_bit = (least( 1u ) << Bit) );
|
||||
BOOST_STATIC_CONSTANT( fast, high_bit_fast = (fast( 1u ) << Bit) );
|
||||
|
||||
BOOST_STATIC_CONSTANT( least, high_bit = impl_type::value );
|
||||
BOOST_STATIC_CONSTANT( fast, high_bit_fast = impl_type::value );
|
||||
|
||||
BOOST_STATIC_CONSTANT( std::size_t, bit_position = impl_type::bit_offset );
|
||||
BOOST_STATIC_CONSTANT( std::size_t, bit_position = Bit );
|
||||
|
||||
}; // boost::high_bit_mask_t
|
||||
|
||||
|
||||
// Specified bit-block mask class declaration ------------------------------//
|
||||
// Makes masks for the lowest N bits
|
||||
// (Specializations are needed when N fills up a type.)
|
||||
|
||||
template < std::size_t Bits >
|
||||
class low_bits_mask_t
|
||||
struct low_bits_mask_t
|
||||
{
|
||||
typedef integer_lo_mask<Bits> impl_type;
|
||||
typedef typename uint_t<Bits>::least least;
|
||||
typedef typename uint_t<Bits>::fast fast;
|
||||
|
||||
public:
|
||||
typedef typename impl_type::value_type least;
|
||||
typedef typename int_fast_t<least>::fast fast;
|
||||
BOOST_STATIC_CONSTANT( least, sig_bits = (~( ~(least( 0u )) << Bits )) );
|
||||
BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );
|
||||
|
||||
BOOST_STATIC_CONSTANT( least, sig_bits = impl_type::value );
|
||||
BOOST_STATIC_CONSTANT( fast, sig_bits_fast = impl_type::value );
|
||||
|
||||
BOOST_STATIC_CONSTANT( std::size_t, bit_count = impl_type::bit_count );
|
||||
BOOST_STATIC_CONSTANT( std::size_t, bit_count = Bits );
|
||||
|
||||
}; // boost::low_bits_mask_t
|
||||
|
||||
|
||||
#define BOOST_LOW_BITS_MASK_SPECIALIZE( Type ) \
|
||||
template < > struct low_bits_mask_t< std::numeric_limits<Type>::digits > { \
|
||||
typedef std::numeric_limits<Type> limits_type; \
|
||||
typedef uint_t<limits_type::digits>::least least; \
|
||||
typedef uint_t<limits_type::digits>::fast fast; \
|
||||
BOOST_STATIC_CONSTANT( least, sig_bits = (~( least(0u) )) ); \
|
||||
BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) ); \
|
||||
BOOST_STATIC_CONSTANT( std::size_t, bit_count = limits_type::digits ); \
|
||||
}
|
||||
|
||||
BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned char );
|
||||
|
||||
#if USHRT_MAX > UCHAR_MAX
|
||||
BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned short );
|
||||
#endif
|
||||
|
||||
#if UINT_MAX > USHRT_MAX
|
||||
BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned int );
|
||||
#endif
|
||||
|
||||
#if ULONG_MAX > UINT_MAX
|
||||
BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned long );
|
||||
#endif
|
||||
|
||||
#undef BOOST_LOW_BITS_MASK_SPECIALIZE
|
||||
|
||||
|
||||
} // namespace boost
|
||||
|
||||
|
||||
|
||||
@ -9,12 +9,11 @@
|
||||
#ifndef BOOST_INTEGER_FWD_HPP
|
||||
#define BOOST_INTEGER_FWD_HPP
|
||||
|
||||
#include <climits> // for UCHAR_MAX, etc.
|
||||
#include <cstddef> // for std::size_t
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_NO_INTRINSIC_WCHAR_T, etc.
|
||||
#include <boost/cstdint.hpp> // for boost::uintmax_t, intmax_t
|
||||
|
||||
#include <boost/detail/extended_integer.hpp> // for BOOST_HAS_XINT, etc.
|
||||
#include <boost/config.hpp> // for BOOST_NO_INTRINSIC_WCHAR_T
|
||||
#include <boost/limits.hpp> // for std::numeric_limits
|
||||
|
||||
|
||||
namespace boost
|
||||
@ -25,13 +24,6 @@ namespace boost
|
||||
|
||||
// Only has typedefs or using statements, with #conditionals
|
||||
|
||||
// ALERT: the forward declarations of items in <boost/integer.hpp> need items
|
||||
// from this header. That means that <boost/cstdint.hpp> cannot #include this
|
||||
// forwarding header, to avoid infinite recursion! One day, maybe
|
||||
// boost::uintmax_t and boost::intmax_t could be segregated into their own
|
||||
// header file (which can't #include this header), <boost/integer.hpp> will use
|
||||
// that header, and <boost/cstdint.hpp> could refer to <boost/integer.hpp>.
|
||||
|
||||
|
||||
// From <boost/integer_traits.hpp> -----------------------------------------//
|
||||
|
||||
@ -73,73 +65,61 @@ template < >
|
||||
template < >
|
||||
class integer_traits< unsigned long >;
|
||||
|
||||
#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && BOOST_HAS_XINT
|
||||
#ifdef ULLONG_MAX
|
||||
template < >
|
||||
class integer_traits< ::boost::detail::xint_t >;
|
||||
class integer_traits< ::boost::long_long_type>;
|
||||
|
||||
template < >
|
||||
class integer_traits< ::boost::detail::uxint_t >;
|
||||
class integer_traits< ::boost::ulong_long_type >;
|
||||
#endif
|
||||
|
||||
|
||||
// From <boost/integer.hpp> ------------------------------------------------//
|
||||
|
||||
template < typename BaseInt >
|
||||
struct fast_integral;
|
||||
|
||||
template < typename LeastInt >
|
||||
struct int_fast_t;
|
||||
|
||||
template < int Bits, typename Signedness >
|
||||
struct sized_integral;
|
||||
|
||||
template < int Bits, typename Signedness >
|
||||
struct exact_integral;
|
||||
|
||||
template < intmax_t MaxValue >
|
||||
struct maximum_signed_integral;
|
||||
|
||||
template < intmax_t MinValue >
|
||||
struct minimum_signed_integral;
|
||||
|
||||
template < uintmax_t Value >
|
||||
struct maximum_unsigned_integral;
|
||||
|
||||
template< int Bits >
|
||||
struct int_t;
|
||||
|
||||
template< int Bits >
|
||||
struct int_exact_t;
|
||||
|
||||
template< int Bits >
|
||||
struct uint_t;
|
||||
|
||||
template< int Bits >
|
||||
struct uint_exact_t;
|
||||
|
||||
template< intmax_t MaxValue >
|
||||
template< long MaxValue >
|
||||
struct int_max_value_t;
|
||||
|
||||
template< intmax_t MinValue >
|
||||
template< long MinValue >
|
||||
struct int_min_value_t;
|
||||
|
||||
template< uintmax_t Value >
|
||||
template< unsigned long Value >
|
||||
struct uint_value_t;
|
||||
|
||||
|
||||
// From <boost/integer/integer_mask.hpp> -----------------------------------//
|
||||
|
||||
template < int Offset >
|
||||
struct integer_hi_mask;
|
||||
|
||||
template < int Length >
|
||||
struct integer_lo_mask;
|
||||
|
||||
template < std::size_t Bit >
|
||||
class high_bit_mask_t;
|
||||
struct high_bit_mask_t;
|
||||
|
||||
template < std::size_t Bits >
|
||||
class low_bits_mask_t;
|
||||
struct low_bits_mask_t;
|
||||
|
||||
template < >
|
||||
struct low_bits_mask_t< ::std::numeric_limits<unsigned char>::digits >;
|
||||
|
||||
#if USHRT_MAX > UCHAR_MAX
|
||||
template < >
|
||||
struct low_bits_mask_t< ::std::numeric_limits<unsigned short>::digits >;
|
||||
#endif
|
||||
|
||||
#if UINT_MAX > USHRT_MAX
|
||||
template < >
|
||||
struct low_bits_mask_t< ::std::numeric_limits<unsigned int>::digits >;
|
||||
#endif
|
||||
|
||||
#if ULONG_MAX > UINT_MAX
|
||||
template < >
|
||||
struct low_bits_mask_t< ::std::numeric_limits<unsigned long>::digits >;
|
||||
#endif
|
||||
|
||||
|
||||
// From <boost/integer/static_log2.hpp> ------------------------------------//
|
||||
|
||||
@ -27,8 +27,6 @@
|
||||
#include <wchar.h>
|
||||
#endif
|
||||
|
||||
#include <boost/detail/extended_integer.hpp> // for BOOST_HAS_XINT, etc.
|
||||
|
||||
|
||||
namespace boost {
|
||||
template<class T>
|
||||
@ -157,28 +155,77 @@ class integer_traits<unsigned long>
|
||||
public detail::integer_traits_base<unsigned long, 0, ULONG_MAX>
|
||||
{ };
|
||||
|
||||
#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && BOOST_HAS_XINT
|
||||
#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T)
|
||||
#if defined(ULLONG_MAX) && defined(BOOST_HAS_LONG_LONG)
|
||||
|
||||
#if defined(__GNUC__) && ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 3)))
|
||||
//
|
||||
// The following code emits warnings when built with -pedantic, and there appears
|
||||
// to be no other way of suppressing these warnings as use of __extension__ has no
|
||||
// effect, so declare the rest of this header a system header.
|
||||
template<>
|
||||
class integer_traits< ::boost::long_long_type>
|
||||
: public std::numeric_limits< ::boost::long_long_type>,
|
||||
public detail::integer_traits_base< ::boost::long_long_type, LLONG_MIN, LLONG_MAX>
|
||||
{ };
|
||||
|
||||
template<>
|
||||
class integer_traits< ::boost::ulong_long_type>
|
||||
: public std::numeric_limits< ::boost::ulong_long_type>,
|
||||
public detail::integer_traits_base< ::boost::ulong_long_type, 0, ULLONG_MAX>
|
||||
{ };
|
||||
|
||||
#elif defined(ULONG_LONG_MAX) && defined(BOOST_HAS_LONG_LONG)
|
||||
|
||||
template<>
|
||||
class integer_traits< ::boost::long_long_type> : public std::numeric_limits< ::boost::long_long_type>, public detail::integer_traits_base< ::boost::long_long_type, LONG_LONG_MIN, LONG_LONG_MAX>{ };
|
||||
template<>
|
||||
class integer_traits< ::boost::ulong_long_type>
|
||||
: public std::numeric_limits< ::boost::ulong_long_type>,
|
||||
public detail::integer_traits_base< ::boost::ulong_long_type, 0, ULONG_LONG_MAX>
|
||||
{ };
|
||||
|
||||
#elif defined(ULONGLONG_MAX) && defined(BOOST_HAS_LONG_LONG)
|
||||
|
||||
template<>
|
||||
class integer_traits< ::boost::long_long_type>
|
||||
: public std::numeric_limits< ::boost::long_long_type>,
|
||||
public detail::integer_traits_base< ::boost::long_long_type, LONGLONG_MIN, LONGLONG_MAX>
|
||||
{ };
|
||||
|
||||
template<>
|
||||
class integer_traits< ::boost::ulong_long_type>
|
||||
: public std::numeric_limits< ::boost::ulong_long_type>,
|
||||
public detail::integer_traits_base< ::boost::ulong_long_type, 0, ULONGLONG_MAX>
|
||||
{ };
|
||||
|
||||
#elif defined(_LLONG_MAX) && defined(_C2) && defined(BOOST_HAS_LONG_LONG)
|
||||
|
||||
template<>
|
||||
class integer_traits< ::boost::long_long_type>
|
||||
: public std::numeric_limits< ::boost::long_long_type>,
|
||||
public detail::integer_traits_base< ::boost::long_long_type, -_LLONG_MAX - _C2, _LLONG_MAX>
|
||||
{ };
|
||||
|
||||
template<>
|
||||
class integer_traits< ::boost::ulong_long_type>
|
||||
: public std::numeric_limits< ::boost::ulong_long_type>,
|
||||
public detail::integer_traits_base< ::boost::ulong_long_type, 0, _ULLONG_MAX>
|
||||
{ };
|
||||
|
||||
#elif defined(BOOST_HAS_LONG_LONG)
|
||||
//
|
||||
# pragma GCC system_header
|
||||
// we have long long but no constants, this happens for example with gcc in -ansi mode,
|
||||
// we'll just have to work out the values for ourselves (assumes 2's compliment representation):
|
||||
//
|
||||
template<>
|
||||
class integer_traits< ::boost::long_long_type>
|
||||
: public std::numeric_limits< ::boost::long_long_type>,
|
||||
public detail::integer_traits_base< ::boost::long_long_type, (1LL << (sizeof(::boost::long_long_type) - 1)), ~(1LL << (sizeof(::boost::long_long_type) - 1))>
|
||||
{ };
|
||||
|
||||
template<>
|
||||
class integer_traits< ::boost::ulong_long_type>
|
||||
: public std::numeric_limits< ::boost::ulong_long_type>,
|
||||
public detail::integer_traits_base< ::boost::ulong_long_type, 0, ~0uLL>
|
||||
{ };
|
||||
|
||||
#endif
|
||||
|
||||
template<>
|
||||
class integer_traits< detail::xint_t >
|
||||
: public std::numeric_limits< detail::xint_t >,
|
||||
public detail::integer_traits_base< detail::xint_t, BOOST_XINT_MIN, BOOST_XINT_MAX >
|
||||
{ };
|
||||
|
||||
template<>
|
||||
class integer_traits< detail::uxint_t >
|
||||
: public std::numeric_limits< detail::uxint_t >,
|
||||
public detail::integer_traits_base< detail::uxint_t, 0u, BOOST_UXINT_MAX >
|
||||
{ };
|
||||
#endif
|
||||
|
||||
} // namespace boost
|
||||
|
||||
Reference in New Issue
Block a user