bitset_core/
slice.rs

1use super::BitSet;
2
3macro_rules! impl_bit_set_slice {
4	([$elem_ty:ty], $bits_per_word:literal) => {
5		impl BitSet for [$elem_ty] {
6			#[inline]
7			fn bit_len(&self) -> usize {
8				self.len() * $bits_per_word
9			}
10
11			#[inline]
12			fn bit_init(&mut self, value: bool) -> &mut Self {
13				let value = <$elem_ty>::wrapping_add(!(value as $elem_ty), 1);
14				for i in 0..self.len() {
15					self[i] = value;
16				}
17				self
18			}
19
20			#[inline]
21			fn bit_test(&self, bit: usize) -> bool {
22				self[bit / $bits_per_word] & (1 << bit % $bits_per_word) != 0
23			}
24			#[inline]
25			fn bit_set(&mut self, bit: usize) -> &mut Self {
26				self[bit / $bits_per_word] |= 1 << bit % $bits_per_word;
27				self
28			}
29			#[inline]
30			fn bit_reset(&mut self, bit: usize) -> &mut Self {
31				self[bit / $bits_per_word] &= !(1 << bit % $bits_per_word);
32				self
33			}
34			#[inline]
35			fn bit_flip(&mut self, bit: usize) -> &mut Self {
36				self[bit / $bits_per_word] ^= 1 << bit % $bits_per_word;
37				self
38			}
39			#[inline]
40			fn bit_cond(&mut self, bit: usize, value: bool) -> &mut Self {
41				let index = bit / $bits_per_word;
42				let mask = 1 << bit % $bits_per_word;
43				self[index] = (self[index] & !mask) | (<$elem_ty>::wrapping_add(!(value as $elem_ty), 1) & mask);
44				self
45			}
46
47			#[inline]
48			fn bit_all(&self) -> bool {
49				for i in 0..self.len() {
50					if self[i] != !0 {
51						return false;
52					}
53				}
54				true
55			}
56			#[inline]
57			fn bit_any(&self) -> bool {
58				for i in 0..self.len() {
59					if self[i] != 0 {
60						return true;
61					}
62				}
63				false
64			}
65
66			#[inline]
67			fn bit_eq(&self, rhs: &Self) -> bool {
68				assert_eq!(self.len(), rhs.len());
69				for i in 0..self.len() {
70					if self[i] != rhs[i] {
71						return false;
72					}
73				}
74				true
75			}
76			#[inline]
77			fn bit_disjoint(&self, rhs: &Self) -> bool {
78				assert_eq!(self.len(), rhs.len());
79				for i in 0..self.len() {
80					if self[i] & rhs[i] != 0 {
81						return false;
82					}
83				}
84				true
85			}
86			#[inline]
87			fn bit_subset(&self, rhs: &Self) -> bool {
88				assert_eq!(self.len(), rhs.len());
89				for i in 0..self.len() {
90					if self[i] | rhs[i] != rhs[i] {
91						return false;
92					}
93				}
94				true
95			}
96
97			#[inline]
98			fn bit_or(&mut self, rhs: &Self) -> &mut Self {
99				assert_eq!(self.len(), rhs.len());
100				for i in 0..self.len() {
101					self[i] |= rhs[i];
102				}
103				self
104			}
105			#[inline]
106			fn bit_and(&mut self, rhs: &Self) -> &mut Self {
107				assert_eq!(self.len(), rhs.len());
108				for i in 0..self.len() {
109					self[i] &= rhs[i];
110				}
111				self
112			}
113			#[inline]
114			fn bit_andnot(&mut self, rhs: &Self) -> &mut Self {
115				assert_eq!(self.len(), rhs.len());
116				for i in 0..self.len() {
117					self[i] &= !rhs[i];
118				}
119				self
120			}
121			#[inline]
122			fn bit_xor(&mut self, rhs: &Self) -> &mut Self {
123				assert_eq!(self.len(), rhs.len());
124				for i in 0..self.len() {
125					self[i] ^= rhs[i];
126				}
127				self
128			}
129			#[inline]
130			fn bit_not(&mut self) -> &mut Self {
131				for i in 0..self.len() {
132					self[i] = !self[i];
133				}
134				self
135			}
136			#[inline]
137			fn bit_mask(&mut self, rhs: &Self, mask: &Self) -> &mut Self {
138				let len = self.len();
139				assert_eq!(len, rhs.len());
140				assert_eq!(len, mask.len());
141				for i in 0..len {
142					self[i] = self[i] & !mask[i] | rhs[i] & mask[i];
143				}
144				self
145			}
146
147			#[inline]
148			fn bit_count(&self) -> usize {
149				let mut result = 0;
150				for i in 0..self.len() {
151					result += self[i].count_ones() as usize;
152				}
153				result
154			}
155		}
156	};
157}
158
159impl_bit_set_slice!([u8], 8);
160impl_bit_set_slice!([u16], 16);
161impl_bit_set_slice!([u32], 32);
162impl_bit_set_slice!([u64], 64);
163impl_bit_set_slice!([u128], 128);
164
165//----------------------------------------------------------------
166
167#[test]
168fn tests() {
169	let mut bytes = [0u8; 32];
170	let mut words = [0u16; 16];
171	let mut dwords = [0u32; 8];
172	let mut qwords = [0u64; 4];
173
174	super::unary_tests(&mut bytes[..]);
175	super::unary_tests(&mut words[..]);
176	super::unary_tests(&mut dwords[..]);
177	super::unary_tests(&mut qwords[..]);
178}
179
180// Tests whether `bit X` is the same bit regardless of underlying primitive used.
181// NOTE: This only works on little endian, nobody cares about big endian anyway.
182#[test]
183fn test_transmute() {
184	for i in 0..32 {
185		let uint = bitset!([0u32; 1]; i);
186		let ubyte = bitset!([0u8; 4]; i);
187		assert_eq!(uint[0], u32::from_ne_bytes(ubyte));
188	}
189}
bitset_core/slice.rs

bitset_core/
slice.rs
