enumset/src/repr.rs

   1 use core::convert::TryInto;
   2 use core::fmt::Debug;
   3 use core::hash::Hash;
   4 use core::ops::*;
   5
   6 /// A trait marking valid underlying bitset storage types and providing the
   7 /// operations `EnumSet` and related types use.
   8 pub trait EnumSetTypeRepr :
   9     // Basic traits used to derive traits
  10     Copy +
  11     Ord +
  12     Eq +
  13     Debug +
  14     Hash +
  15     // Operations used by enumset
  16     BitAnd<Output = Self> +
  17     BitOr<Output = Self> +
  18     BitXor<Output = Self> +
  19     Not<Output = Self> +
  20 {
  21     const WIDTH: u32;
  22
  23     fn is_empty(&self) -> bool;
  24     fn empty() -> Self;
  25
  26     fn add_bit(&mut self, bit: u32);
  27     fn remove_bit(&mut self, bit: u32);
  28     fn has_bit(&self, bit: u32) -> bool;
  29
  30     fn count_ones(&self) -> u32;
  31     fn count_remaining_ones(&self, cursor: u32) -> usize;
  32     fn leading_zeros(&self) -> u32;
  33     fn trailing_zeros(&self) -> u32;
  34
  35     fn and_not(&self, other: Self) -> Self;
  36
  37     fn from_u8(v: u8) -> Self;
  38     fn from_u16(v: u16) -> Self;
  39     fn from_u32(v: u32) -> Self;
  40     fn from_u64(v: u64) -> Self;
  41     fn from_u128(v: u128) -> Self;
  42     fn from_usize(v: usize) -> Self;
  43
  44     fn to_u8(&self) -> u8;
  45     fn to_u16(&self) -> u16;
  46     fn to_u32(&self) -> u32;
  47     fn to_u64(&self) -> u64;
  48     fn to_u128(&self) -> u128;
  49     fn to_usize(&self) -> usize;
  50
  51     fn from_u8_opt(v: u8) -> Option<Self>;
  52     fn from_u16_opt(v: u16) -> Option<Self>;
  53     fn from_u32_opt(v: u32) -> Option<Self>;
  54     fn from_u64_opt(v: u64) -> Option<Self>;
  55     fn from_u128_opt(v: u128) -> Option<Self>;
  56     fn from_usize_opt(v: usize) -> Option<Self>;
  57
  58     fn to_u8_opt(&self) -> Option<u8>;
  59     fn to_u16_opt(&self) -> Option<u16>;
  60     fn to_u32_opt(&self) -> Option<u32>;
  61     fn to_u64_opt(&self) -> Option<u64>;
  62     fn to_u128_opt(&self) -> Option<u128>;
  63     fn to_usize_opt(&self) -> Option<usize>;
  64 }
  65 macro_rules! prim {
  66     ($name:ty, $width:expr) => {
  67         impl EnumSetTypeRepr for $name {
  68             const WIDTH: u32 = $width;
  69
  70             #[inline(always)]
  71             fn is_empty(&self) -> bool {
  72                 *self == 0
  73             }
  74             #[inline(always)]
  75             fn empty() -> Self {
  76                 0
  77             }
  78
  79             #[inline(always)]
  80             fn add_bit(&mut self, bit: u32) {
  81                 *self |= 1 << bit as $name;
  82             }
  83             #[inline(always)]
  84             fn remove_bit(&mut self, bit: u32) {
  85                 *self &= !(1 << bit as $name);
  86             }
  87             #[inline(always)]
  88             fn has_bit(&self, bit: u32) -> bool {
  89                 (self & (1 << bit as $name)) != 0
  90             }
  91
  92             #[inline(always)]
  93             fn count_ones(&self) -> u32 {
  94                 (*self).count_ones()
  95             }
  96             #[inline(always)]
  97             fn leading_zeros(&self) -> u32 {
  98                 (*self).leading_zeros()
  99             }
 100             #[inline(always)]
 101             fn trailing_zeros(&self) -> u32 {
 102                 (*self).trailing_zeros()
 103             }
 104
 105             #[inline(always)]
 106             fn and_not(&self, other: Self) -> Self {
 107                 (*self) & !other
 108             }
 109
 110             #[inline(always)]
 111             fn count_remaining_ones(&self, cursor: u32) -> usize {
 112                 let left_mask = !((1 as $name)
 113                     .checked_shl(cursor)
 114                     .unwrap_or(0)
 115                     .wrapping_sub(1));
 116                 (*self & left_mask).count_ones() as usize
 117             }
 118
 119             #[inline(always)]
 120             fn from_u8(v: u8) -> Self {
 121                 v as $name
 122             }
 123             #[inline(always)]
 124             fn from_u16(v: u16) -> Self {
 125                 v as $name
 126             }
 127             #[inline(always)]
 128             fn from_u32(v: u32) -> Self {
 129                 v as $name
 130             }
 131             #[inline(always)]
 132             fn from_u64(v: u64) -> Self {
 133                 v as $name
 134             }
 135             #[inline(always)]
 136             fn from_u128(v: u128) -> Self {
 137                 v as $name
 138             }
 139             #[inline(always)]
 140             fn from_usize(v: usize) -> Self {
 141                 v as $name
 142             }
 143
 144             #[inline(always)]
 145             fn to_u8(&self) -> u8 {
 146                 (*self) as u8
 147             }
 148             #[inline(always)]
 149             fn to_u16(&self) -> u16 {
 150                 (*self) as u16
 151             }
 152             #[inline(always)]
 153             fn to_u32(&self) -> u32 {
 154                 (*self) as u32
 155             }
 156             #[inline(always)]
 157             fn to_u64(&self) -> u64 {
 158                 (*self) as u64
 159             }
 160             #[inline(always)]
 161             fn to_u128(&self) -> u128 {
 162                 (*self) as u128
 163             }
 164             #[inline(always)]
 165             fn to_usize(&self) -> usize {
 166                 (*self) as usize
 167             }
 168
 169             #[inline(always)]
 170             fn from_u8_opt(v: u8) -> Option<Self> {
 171                 v.try_into().ok()
 172             }
 173             #[inline(always)]
 174             fn from_u16_opt(v: u16) -> Option<Self> {
 175                 v.try_into().ok()
 176             }
 177             #[inline(always)]
 178             fn from_u32_opt(v: u32) -> Option<Self> {
 179                 v.try_into().ok()
 180             }
 181             #[inline(always)]
 182             fn from_u64_opt(v: u64) -> Option<Self> {
 183                 v.try_into().ok()
 184             }
 185             #[inline(always)]
 186             fn from_u128_opt(v: u128) -> Option<Self> {
 187                 v.try_into().ok()
 188             }
 189             #[inline(always)]
 190             fn from_usize_opt(v: usize) -> Option<Self> {
 191                 v.try_into().ok()
 192             }
 193
 194             #[inline(always)]
 195             fn to_u8_opt(&self) -> Option<u8> {
 196                 (*self).try_into().ok()
 197             }
 198             #[inline(always)]
 199             fn to_u16_opt(&self) -> Option<u16> {
 200                 (*self).try_into().ok()
 201             }
 202             #[inline(always)]
 203             fn to_u32_opt(&self) -> Option<u32> {
 204                 (*self).try_into().ok()
 205             }
 206             #[inline(always)]
 207             fn to_u64_opt(&self) -> Option<u64> {
 208                 (*self).try_into().ok()
 209             }
 210             #[inline(always)]
 211             fn to_u128_opt(&self) -> Option<u128> {
 212                 (*self).try_into().ok()
 213             }
 214             #[inline(always)]
 215             fn to_usize_opt(&self) -> Option<usize> {
 216                 (*self).try_into().ok()
 217             }
 218         }
 219     };
 220 }
 221 prim!(u8, 8);
 222 prim!(u16, 16);
 223 prim!(u32, 32);
 224 prim!(u64, 64);
 225 prim!(u128, 128);