boost/integer/integer_mask.hpp

   1 //  Boost integer/integer_mask.hpp header file  ------------------------------//
   2
   3 //  (C) Copyright Daryle Walker 2001.
   4 //  Distributed under the Boost Software License, Version 1.0. (See
   5 //  accompanying file LICENSE_1_0.txt or copy at
   6 //  http://www.boost.org/LICENSE_1_0.txt)
   7
   8 //  See http://www.boost.org for updates, documentation, and revision history.
   9
  10 #ifndef BOOST_INTEGER_INTEGER_MASK_HPP
  11 #define BOOST_INTEGER_INTEGER_MASK_HPP
  12
  13 #include <boost/integer_fwd.hpp>  // self include
  14
  15 #include <boost/config.hpp>             // for BOOST_STATIC_CONSTANT
  16 #include <boost/cstdint.hpp>            // for boost::uintmax_t
  17 #include <boost/integer.hpp>            // for boost::sized_integral
  18 #include <boost/limits.hpp>             // for std::numeric_limits
  19 #include <boost/mpl/and.hpp>            // for boost::mpl::and_
  20 #include <boost/mpl/bitwise.hpp>        // for boost::mpl::bitor_, shift_left
  21 #include <boost/mpl/bool.hpp>           // for boost::mpl::true_
  22 #include <boost/mpl/comparison.hpp>     // for boost::mpl::greater_equal, etc.
  23 #include <boost/mpl/empty_base.hpp>     // for boost::mpl::empty_base
  24 #include <boost/mpl/if.hpp>             // for boost::mpl::if_
  25 #include <boost/mpl/int.hpp>            // for boost::mpl::int_
  26 #include <boost/mpl/integral_c.hpp>     // for boost::integral_c
  27 #include <boost/mpl/next_prior.hpp>     // for boost::mpl::next, prior
  28 #include <boost/utility/enable_if.hpp>  // for boost::enable_if
  29
  30 #include <cstddef>  // for std::size_t
  31
  32
  33 namespace boost
  34 {
  35 namespace detail
  36 {
  37
  38 //  Helper templates  --------------------------------------------------------//
  39
  40 template < int Bits >
  41 struct hi_integer_mask_builder1
  42 {
  43     typedef boost::mpl::int_<Bits>  bit_count_type;
  44
  45     typedef typename boost::mpl::next<bit_count_type>::type
  46       mask_length_type;
  47     typedef boost::sized_integral<mask_length_type::value, unsigned>
  48       mask_type;
  49
  50     typedef boost::mpl::integral_c<typename mask_type::type, 1>  one_type;
  51     typedef boost::mpl::shift_left<one_type, bit_count_type>  result_type;
  52 };
  53
  54 template < int Bits >
  55 struct hi_integer_mask_builder2
  56 {
  57     typedef boost::mpl::int_<Bits>  bit_count_type;
  58
  59     typedef boost::mpl::greater_equal< bit_count_type, boost::mpl::int_<0> >
  60       lo_bound_type;
  61     typedef boost::mpl::less< bit_count_type,
  62      boost::mpl::int_<std::numeric_limits<boost::uintmax_t>::digits> >
  63       hi_bound_type;
  64     typedef boost::mpl::and_<lo_bound_type, hi_bound_type>  count_valid_type;
  65 };
  66
  67 template < int Bits, class Enable = void >
  68 struct hi_integer_mask_builder3
  69 {
  70     BOOST_STATIC_CONSTANT( bool, is_specialized = false );
  71 };
  72
  73 template < int Bits >
  74 struct hi_integer_mask_builder3< Bits, typename boost::enable_if<typename
  75  hi_integer_mask_builder2<Bits>::count_valid_type>::type >
  76     : hi_integer_mask_builder1<Bits>::result_type
  77 {
  78     BOOST_STATIC_CONSTANT( bool, is_specialized = true );
  79 };
  80
  81 template < int Bits >
  82 struct lo_integer_mask_builder1
  83 {
  84     typedef boost::mpl::int_<Bits>  bit_count_type;
  85
  86     typedef typename boost::mpl::prior<bit_count_type>::type
  87       shift_length_type;
  88     typedef boost::sized_integral<bit_count_type::value, unsigned>
  89       mask_type;
  90
  91     typedef boost::mpl::integral_c<typename mask_type::type, 1>  one_type;
  92     typedef boost::mpl::shift_left<one_type, shift_length_type>
  93       high_bit_type;
  94     typedef typename boost::mpl::prior<high_bit_type>::type  low_bits_type;
  95     typedef boost::mpl::bitor_<high_bit_type, low_bits_type>  result_type;
  96 };
  97
  98 template <  >
  99 struct lo_integer_mask_builder1< 0 >
 100 {
 101     // Let's not deal with negative interim values....
 102     typedef boost::mpl::integral_c<unsigned char, 0u>  result_type;
 103 };
 104
 105 template < int Bits >
 106 struct lo_integer_mask_builder2
 107 {
 108     typedef boost::mpl::int_<Bits>  bit_count_type;
 109
 110     typedef boost::mpl::greater_equal< bit_count_type, boost::mpl::int_<0> >
 111       lo_bound_type;
 112     typedef boost::mpl::less_equal< bit_count_type,
 113      boost::mpl::int_<std::numeric_limits<boost::uintmax_t>::digits> >
 114       hi_bound_type;
 115     typedef boost::mpl::and_<lo_bound_type, hi_bound_type>  count_valid_type;
 116 };
 117
 118 template <  >
 119 struct lo_integer_mask_builder2< 0 >
 120 {
 121     typedef boost::mpl::true_  count_valid_type;
 122 };
 123
 124 template < int Bits, class Enable = void >
 125 struct lo_integer_mask_builder3
 126 {
 127     BOOST_STATIC_CONSTANT( bool, is_specialized = false );
 128     // No MPL Integral Constant to inherit from
 129 };
 130
 131 template < int Bits >
 132 struct lo_integer_mask_builder3< Bits, typename enable_if<typename
 133  lo_integer_mask_builder2<Bits>::count_valid_type>::type >
 134     : lo_integer_mask_builder1<Bits>::result_type
 135 {
 136     BOOST_STATIC_CONSTANT( bool, is_specialized = true );
 137 };
 138
 139 } // namespace detail
 140
 141
 142 //  MPL-compatible integer mask class templates  -----------------------------//
 143
 144 // Displaced single-bit mask, 1 << Offset, 0 <= Offset < BitLengthOf(uintmax_t)
 145 template < int Offset >
 146 struct integer_hi_mask
 147     : detail::hi_integer_mask_builder3<Offset>
 148 {
 149     BOOST_STATIC_CONSTANT( int, bit_offset = Offset );
 150 };
 151
 152 // Lowest bit-group mask, 2**Length - 1, 0 <= Length <= BitLengthOf(uintmax_t)
 153 template < int Length >
 154 struct integer_lo_mask
 155     : detail::lo_integer_mask_builder3<Length>
 156 {
 157     BOOST_STATIC_CONSTANT( int, bit_count = Length );
 158 };
 159
 160
 161 //  Specified single-bit mask class declaration  -----------------------------//
 162 //  (Lowest bit starts counting at 0.)
 163
 164 template < std::size_t Bit >
 165 class high_bit_mask_t
 166 {
 167     typedef integer_hi_mask<Bit>  impl_type;
 168
 169 public:
 170     typedef typename impl_type::value_type   least;
 171     typedef typename int_fast_t<least>::fast  fast;
 172
 173     BOOST_STATIC_CONSTANT( least, high_bit = impl_type::value );
 174     BOOST_STATIC_CONSTANT( fast, high_bit_fast = impl_type::value );
 175
 176     BOOST_STATIC_CONSTANT( std::size_t, bit_position = impl_type::bit_offset );
 177
 178 };  // boost::high_bit_mask_t
 179
 180
 181 //  Specified bit-block mask class declaration  ------------------------------//
 182 //  Makes masks for the lowest N bits
 183
 184 template < std::size_t Bits >
 185 class low_bits_mask_t
 186 {
 187     typedef integer_lo_mask<Bits>  impl_type;
 188
 189 public:
 190     typedef typename impl_type::value_type   least;
 191     typedef typename int_fast_t<least>::fast  fast;
 192
 193     BOOST_STATIC_CONSTANT( least, sig_bits = impl_type::value );
 194     BOOST_STATIC_CONSTANT( fast, sig_bits_fast = impl_type::value );
 195
 196     BOOST_STATIC_CONSTANT( std::size_t, bit_count = impl_type::bit_count );
 197
 198 };  // boost::low_bits_mask_t
 199
 200
 201 }  // namespace boost
 202
 203
 204 #endif  // BOOST_INTEGER_INTEGER_MASK_HPP