bitset-core 0.1.1

Straightforward, no-std compatible, simd optimized, BitSet API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use super::BitSet;

macro_rules! impl_bit_set_uint {
	($ty:ty, $bits_per_word:literal) => {
		impl BitSet for $ty {
			#[inline]
			fn bit_len(&self) -> usize {
				$bits_per_word
			}
			#[inline]
			fn bit_init(&mut self, value: bool) -> &mut Self {
				*self = <$ty>::wrapping_add(!(value as $ty), 1);
				self
			}
			#[inline]
			fn bit_test(&self, bit: usize) -> bool {
				*self & (1 << bit as u32) != 0
			}
			#[inline]
			fn bit_set(&mut self, bit: usize) -> &mut Self {
				*self |= 1 << bit as u32;
				self
			}
			#[inline]
			fn bit_reset(&mut self, bit: usize) -> &mut Self {
				*self &= !(1 << bit as u32);
				self
			}
			#[inline]
			fn bit_flip(&mut self, bit: usize) -> &mut Self {
				*self ^= 1 << bit as u32;
				self
			}
			#[inline]
			fn bit_cond(&mut self, bit: usize, value: bool) -> &mut Self {
				let mask = 1 << bit as u32;
				*self = (*self & !mask) | (<$ty>::wrapping_add(!(value as $ty), 1) & mask);
				self
			}
			#[inline]
			fn bit_all(&self) -> bool {
				*self == !0
			}
			#[inline]
			fn bit_any(&self) -> bool {
				*self != 0
			}
			#[inline]
			fn bit_none(&self) -> bool {
				*self == 0
			}
			#[inline]
			fn bit_eq(&self, rhs: &Self) -> bool {
				*self == *rhs
			}
			#[inline]
			fn bit_disjoint(&self, rhs: &Self) -> bool {
				*self & *rhs == 0
			}
			#[inline]
			fn bit_subset(&self, rhs: &Self) -> bool {
				*self | *rhs == *rhs
			}
			#[inline]
			fn bit_superset(&self, rhs: &Self) -> bool {
				*self | *rhs == *self
			}
			#[inline]
			fn bit_or(&mut self, rhs: &Self) -> &mut Self {
				*self |= *rhs;
				self
			}
			#[inline]
			fn bit_and(&mut self, rhs: &Self) -> &mut Self {
				*self &= *rhs;
				self
			}
			#[inline]
			fn bit_andnot(&mut self, rhs: &Self) -> &mut Self {
				*self &= !*rhs;
				self
			}
			#[inline]
			fn bit_xor(&mut self, rhs: &Self) -> &mut Self {
				*self ^= *rhs;
				self
			}
			#[inline]
			fn bit_not(&mut self) -> &mut Self {
				*self = !*self;
				self
			}
			#[inline]
			fn bit_mask(&mut self, rhs: &Self, mask: &Self) -> &mut Self {
				*self = *self & !*mask | *rhs & *mask;
				self
			}
			#[inline]
			fn bit_count(&self) -> usize {
				self.count_ones() as usize
			}
		}
	};
}

impl_bit_set_uint!(u8, 8);
impl_bit_set_uint!(u16, 16);
impl_bit_set_uint!(u32, 32);
impl_bit_set_uint!(u64, 64);
impl_bit_set_uint!(u128, 128);

//----------------------------------------------------------------

#[test]
fn tests() {
	let mut bytes = 0u8;
	let mut words = 0u16;
	let mut dwords = 0u32;
	let mut qwords = 0u64;

	super::unary_tests(&mut bytes);
	super::unary_tests(&mut words);
	super::unary_tests(&mut dwords);
	super::unary_tests(&mut qwords);
}