crab_vault_utils/
bitmap.rs

1//! # 位图模块
2//!
3//! 这个模块提供了一个通用的 [`Bitmap`] 结构，用于高效地进行位操作。
4//!
5//! [`Bitmap`] 由一个实现了 [`BitStorage`] trait 的泛型整数类型（如 `u8`, `u16`, `u32`, `u64`, `u128`）支持。
6//! 它封装了底层的位运算，提供了创建、修改、查询位图以及在置位 (1) 和未置位 (0) 的位上进行迭代的功能。
7//!
8//! ## 主要功能
9//!
10//! - **泛型实现**: 可以使用任何常见的无符号整数作为底层存储。
11//! - **完整的位运算**: 支持 `&`, `|`, `^`, `!` 等所有标准位运算符。
12//! - **迭代器**: 提供 [`PositiveIter`] 和 [`NegativeIter`]，分别用于遍历值为 1 和 0 的位的索引。
13//! - **丰富的 API**: 包含 [`set`](Bitmap::set), [`get`](Bitmap::get), [`count_ones`](Bitmap::count_ones), [`any`](Bitmap::any), [`all`](Bitmap::all), [`none`](Bitmap::none) 等常用方法。
14//!
15//! ## 示例
16//!
17//! ```
18//! # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
19//! // 使用 u32 作为存储，创建一个 32 位的位图
20//! let mut artists = Bitmap::<u32>::new();
21//!
22//! // 将索引为 2, 8, 9 的位设置为 1
23//! artists.set(2, true);
24//! artists.set(8, true);
25//! artists.set(9, true);
26//!
27//! // 检查索引为 8 的位是否为 1
28//! assert!(artists.get(8));
29//! // 检查索引为 5 的位是否为 0
30//! assert!(!artists.get(5));
31//!
32//! // 计算有多少个位被设置了
33//! assert_eq!(artists.count_ones(), 3);
34//!
35//! // 使用迭代器收集所有值为 1 的位的索引
36//! let set_bits: Vec<usize> = artists.iter_ones().collect();
37//! assert_eq!(set_bits, vec![2, 8, 9]);
38//!
39//! // 创建另一个位图并进行合并
40//! let mut other_artists = Bitmap::<u32>::new();
41//! other_artists.set(9, true);
42//! other_artists.set(15, true);
43//!
44//! let all_artists = artists | other_artists;
45//! let expected_bits: Vec<usize> = all_artists.iter_ones().collect();
46//! assert_eq!(expected_bits, vec![2, 8, 9, 15]);
47//! ```
48
49use std::fmt::Debug;
50use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Not, Shl, Shr};
51
52pub trait BitStorage:
53    Copy
54    + Default
55    + Debug
56    + BitAnd<Output = Self>
57    + BitAndAssign
58    + BitOr<Output = Self>
59    + BitOrAssign
60    + BitXor<Output = Self>
61    + BitXorAssign
62    + Not<Output = Self>
63    + From<u8>
64    + Shl<usize, Output = Self>
65    + Shr<usize, Output = Self>
66    + PartialEq
67    + Eq
68{
69    const BITS: usize;
70    fn trailing_zeros(self) -> u32;
71    fn count_ones(self) -> u32;
72    fn count_zeros(self) -> u32;
73}
74
75macro_rules! impl_bit_storage_for_basic_types {
76    ($($storage_type: ty), *) => {
77        $(
78            impl BitStorage for $storage_type {
79                const BITS: usize = std::mem::size_of::<$storage_type>() * 8;
80
81                #[inline]
82                fn trailing_zeros(self) -> u32 {
83                    self.trailing_zeros()
84                }
85
86                #[inline]
87                fn count_ones(self) -> u32 {
88                    self.count_ones()
89                }
90
91                #[inline]
92                fn count_zeros(self) -> u32 {
93                    self.count_zeros()
94                }
95            }
96        )*
97    };
98}
99
100impl_bit_storage_for_basic_types!(u8, u16, u32, u64, u128);
101
102/// 一个通用的位图结构，由一个实现了 [`BitStorage`] 的类型支持。
103///
104/// # 示例
105/// ```
106/// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
107/// // 使用 u16 作为存储类型，总共 16 位
108/// let mut bitmap = Bitmap::<u16>::new();
109/// bitmap.set(3, true);
110/// bitmap.set(5, true);
111///
112/// assert!(bitmap.get(3));
113/// assert!(!bitmap.get(4));
114///
115/// let positions: Vec<usize> = bitmap.iter_ones().collect();
116/// assert_eq!(positions, vec![3, 5]);
117/// ```
118#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
119pub struct Bitmap<T: BitStorage> {
120    inner: T,
121}
122
123/// 一个迭代器，用于遍历位图中所有值为 1 (positive) 的位索引。
124pub struct PositiveIter<T: BitStorage> {
125    bitmap: Bitmap<T>,
126}
127
128/// 一个迭代器，用于遍历位图中所有值为 0 (negative) 的位索引。
129pub struct NegativeIter<T: BitStorage> {
130    bitmap: Bitmap<T>,
131}
132
133impl<T: BitStorage> From<NegativeIter<T>> for PositiveIter<T> {
134    fn from(NegativeIter { bitmap }: NegativeIter<T>) -> Self {
135        Self { bitmap }
136    }
137}
138
139impl<T: BitStorage> From<PositiveIter<T>> for NegativeIter<T> {
140    fn from(PositiveIter { bitmap }: PositiveIter<T>) -> Self {
141        Self { bitmap }
142    }
143}
144
145impl<T: BitStorage> Iterator for PositiveIter<T> {
146    type Item = usize;
147
148    fn next(&mut self) -> Option<Self::Item> {
149        if self.bitmap.inner == T::from(0) {
150            return None;
151        }
152
153        let next_bit_pos = self.bitmap.inner.trailing_zeros() as usize;
154
155        // 清除刚刚找到的位，以便下一次迭代
156        let mask = T::from(1) << next_bit_pos;
157        self.bitmap.inner &= !mask;
158        Some(next_bit_pos)
159    }
160}
161
162impl<T: BitStorage> Iterator for NegativeIter<T> {
163    type Item = usize;
164
165    fn next(&mut self) -> Option<Self::Item> {
166        // 如果所有位都为 1，则没有 0 可以迭代
167        if self.bitmap.inner == !T::from(0) {
168            return None;
169        }
170
171        let next_bit_pos = (!self.bitmap.inner).trailing_zeros() as usize;
172
173        // 设置刚刚找到的位为 1，以便下一次迭代
174        let mask = T::from(1) << next_bit_pos;
175        self.bitmap.inner |= mask;
176        Some(next_bit_pos)
177    }
178}
179
180impl<T: BitStorage> PositiveIter<T> {
181    /// 将正迭代器（遍历 1）转换为负迭代器（遍历 0）。
182    ///
183    /// # 示例
184    /// ```
185    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
186    /// let mut bitmap = Bitmap::<u8>::new();
187    /// bitmap.set(1, true);
188    /// bitmap.set(3, true);
189    ///
190    /// let positive_iter = bitmap.iter_ones();
191    /// let negative_iter = positive_iter.invert();
192    /// let zeros: Vec<usize> = negative_iter.collect();
193    ///
194    /// assert_eq!(zeros, vec![0, 2, 4, 5, 6, 7]);
195    /// ```
196    #[inline]
197    pub fn invert(self) -> NegativeIter<T> {
198        self.into()
199    }
200}
201
202impl<T: BitStorage> NegativeIter<T> {
203    /// 将负迭代器（遍历 0）转换为正迭代器（遍历 1）。
204    ///
205    /// # 示例
206    /// ```
207    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
208    /// let mut bitmap = Bitmap::<u8>::new_full();
209    /// bitmap.set(1, false);
210    /// bitmap.set(3, false);
211    ///
212    /// let negative_iter = bitmap.iter_zeros();
213    /// let positive_iter = negative_iter.invert();
214    /// let ones: Vec<usize> = positive_iter.collect();
215    ///
216    /// assert_eq!(ones, vec![0, 2, 4, 5, 6, 7]);
217    /// ```
218    #[inline]
219    pub fn invert(self) -> PositiveIter<T> {
220        self.into()
221    }
222}
223
224impl<T: BitStorage> IntoIterator for &Bitmap<T> {
225    type Item = usize;
226    type IntoIter = PositiveIter<T>;
227
228    #[inline]
229    fn into_iter(self) -> Self::IntoIter {
230        self.iter_ones()
231    }
232}
233
234impl<T: BitStorage> IntoIterator for Bitmap<T> {
235    type Item = usize;
236    type IntoIter = PositiveIter<T>;
237
238    #[inline]
239    fn into_iter(self) -> Self::IntoIter {
240        self.iter_ones()
241    }
242}
243
244impl<T: BitStorage> From<T> for Bitmap<T> {
245    #[inline]
246    fn from(val: T) -> Self {
247        Self { inner: val }
248    }
249}
250
251impl<T: BitStorage> Bitmap<T> {
252    /// 创建一个所有位都为 0 的空位图。
253    ///
254    /// # 示例
255    /// ```
256    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
257    /// let bitmap = Bitmap::<u16>::new_empty();
258    /// assert!(bitmap.none());
259    /// assert_eq!(bitmap.count_ones(), 0);
260    /// ```
261    #[inline]
262    pub fn new_empty() -> Self {
263        Self { inner: T::from(0) }
264    }
265
266    /// 创建一个所有位都为 1 的全满位图。
267    ///
268    /// # 示例
269    /// ```
270    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
271    /// let bitmap = Bitmap::<u8>::new_full();
272    /// assert!(bitmap.all());
273    /// assert_eq!(bitmap.count_ones(), 8);
274    /// ```
275    #[inline]
276    pub fn new_full() -> Self {
277        Self { inner: !T::from(0) }
278    }
279
280    /// 创建一个空的位图，是 `new_empty` 的别名。
281    ///
282    /// # 示例
283    /// ```
284    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
285    /// let bitmap = Bitmap::<u32>::new();
286    /// assert!(bitmap.none());
287    /// ```
288    #[inline]
289    pub fn new() -> Self {
290        Self::new_empty()
291    }
292
293    /// 返回一个迭代器，用于遍历所有值为 1 的位的索引。
294    ///
295    /// # 示例
296    /// ```
297    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
298    /// let mut bitmap = Bitmap::<u8>::new();
299    /// bitmap.set(2, true);
300    /// bitmap.set(6, true);
301    /// let ones: Vec<usize> = bitmap.iter_ones().collect();
302    /// assert_eq!(ones, vec![2, 6]);
303    /// ```
304    #[inline]
305    pub const fn iter_ones(&self) -> PositiveIter<T> {
306        PositiveIter { bitmap: *self }
307    }
308
309    /// 返回一个迭代器，用于遍历所有值为 0 的位的索引。
310    ///
311    /// # 示例
312    /// ```
313    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
314    /// let mut bitmap = Bitmap::<u8>::new();
315    /// bitmap.set(0, true);
316    /// bitmap.set(1, true);
317    /// bitmap.set(2, true);
318    /// bitmap.set(3, true);
319    /// // 内部值为 ...00001111
320    /// let zeros: Vec<usize> = bitmap.iter_zeros().collect();
321    /// assert_eq!(zeros, vec![4, 5, 6, 7]);
322    /// ```
323    #[inline]
324    pub const fn iter_zeros(&self) -> NegativeIter<T> {
325        NegativeIter { bitmap: *self }
326    }
327
328    /// 设置指定索引的位。
329    ///
330    /// `true` 表示设置为 1，`false` 表示设置为 0。
331    ///
332    /// # Panics
333    ///
334    /// 如果 `idx` 超出位图的范围（`idx >= T::BITS`），在调试模式下会触发 panic。
335    ///
336    /// # 示例
337    /// ```
338    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
339    /// let mut bitmap = Bitmap::<u8>::new();
340    /// bitmap.set(5, true);
341    /// assert!(bitmap.get(5));
342    /// bitmap.set(5, false);
343    /// assert!(!bitmap.get(5));
344    /// ```
345    #[inline]
346    pub fn set(&mut self, idx: usize, set: bool) {
347        debug_assert!(idx < T::BITS, "Index out of bounds");
348        let mask = T::from(1) << idx;
349        if set {
350            self.inner |= mask;
351        } else {
352            self.inner &= !mask;
353        }
354    }
355
356    /// 获取指定索引的位的值。
357    ///
358    /// 返回 `true` 如果该位为 1，否则返回 `false`。
359    ///
360    /// # Panics
361    ///
362    /// 如果 `idx` 超出位图的范围（`idx >= T::BITS`），在调试模式下会触发 panic。
363    ///
364    /// # 示例
365    /// ```
366    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
367    /// let mut bitmap = Bitmap::<u8>::new();
368    /// bitmap.set(7, true);
369    /// assert_eq!(bitmap.get(7), true);
370    /// assert_eq!(bitmap.get(0), false);
371    /// ```
372    #[inline]
373    pub fn get(&self, idx: usize) -> bool {
374        debug_assert!(idx < T::BITS, "Index out of bounds");
375        let mask = T::from(1) << idx;
376        (self.inner & mask) != T::from(0)
377    }
378
379    /// 检查指定索引的位是否为 1。`get` 的别名。
380    ///
381    /// # 示例
382    /// ```
383    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
384    /// let mut bitmap = Bitmap::<u8>::new();
385    /// bitmap.set(1, true);
386    /// assert!(bitmap.is_one_on(1));
387    /// ```
388    #[inline]
389    pub fn is_one_on(&self, idx: usize) -> bool {
390        self.get(idx)
391    }
392
393    /// 检查指定索引的位是否为 0。
394    ///
395    /// # 示例
396    /// ```
397    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
398    /// let mut bitmap = Bitmap::<u8>::new();
399    /// bitmap.set(1, true);
400    /// assert!(bitmap.is_zero_on(0));
401    /// ```
402    #[inline]
403    pub fn is_zero_on(&self, idx: usize) -> bool {
404        !self.get(idx)
405    }
406
407    /// 将两个位图进行合并（并集），等同于 `|` 按位或操作。
408    ///
409    /// # 示例
410    /// ```
411    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
412    /// let mut b1 = Bitmap::<u8>::new();
413    /// b1.set(1, true); // 00000010
414    /// let mut b2 = Bitmap::<u8>::new();
415    /// b2.set(2, true); // 00000100
416    ///
417    /// let merged = b1.merge(b2); // 00000110
418    /// assert!(merged.get(1));
419    /// assert!(merged.get(2));
420    /// ```
421    #[inline]
422    pub fn merge(self, rhs: Bitmap<T>) -> Bitmap<T> {
423        self | rhs
424    }
425
426    /// 计算值为 1 的位的数量。
427    ///
428    /// # 示例
429    /// ```
430    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
431    /// let mut bitmap = Bitmap::<u8>::new();
432    /// bitmap.set(0, true);
433    /// bitmap.set(2, true);
434    /// bitmap.set(4, true);
435    /// assert_eq!(bitmap.count_ones(), 3);
436    /// ```
437    #[inline]
438    pub fn count_ones(&self) -> u32 {
439        self.inner.count_ones()
440    }
441
442    /// 计算值为 0 的位的数量。
443    ///
444    /// # 示例
445    /// ```
446    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
447    /// let mut bitmap = Bitmap::<u8>::new();
448    /// bitmap.set(0, true);
449    /// bitmap.set(2, true);
450    /// bitmap.set(4, true);
451    /// // u8 有 8 位，3 个是 1，所以 5 个是 0
452    /// assert_eq!(bitmap.count_zeros(), 5);
453    /// ```
454    #[inline]
455    pub fn count_zeros(&self) -> u32 {
456        T::BITS as u32 - self.inner.count_ones()
457    }
458
459    /// 检查位图中是否至少有一个位是 1。
460    ///
461    /// # 示例
462    /// ```
463    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
464    /// let mut b1 = Bitmap::<u8>::new();
465    /// b1.set(3, true);
466    /// assert!(b1.any());
467    ///
468    /// let b2 = Bitmap::<u8>::new();
469    /// assert!(!b2.any());
470    /// ```
471    #[inline]
472    pub fn any(&self) -> bool {
473        self.inner != T::from(0)
474    }
475
476    /// 检查位图中是否所有位都是 1。
477    ///
478    /// # 示例
479    /// ```
480    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
481    /// let b1 = Bitmap::<u8>::new_full();
482    /// assert!(b1.all());
483    ///
484    /// let mut b2 = Bitmap::<u8>::new_full();
485    /// b2.set(4, false);
486    /// assert!(!b2.all());
487    /// ```
488    #[inline]
489    pub fn all(&self) -> bool {
490        self.inner == !T::from(0)
491    }
492
493    /// 检查位图中是否所有位都是 0。
494    ///
495    /// # 示例
496    /// ```
497    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
498    /// let b1 = Bitmap::<u8>::new();
499    /// assert!(b1.none());
500    ///
501    /// let mut b2 = Bitmap::<u8>::new();
502    /// b2.set(0, true);
503    /// assert!(!b2.none());
504    /// ```
505    #[inline]
506    pub fn none(&self) -> bool {
507        self.inner == T::from(0)
508    }
509
510    /// 查找第一个值为 1 的位的索引。
511    ///
512    /// 如果所有位都为 0，则返回 `None`。
513    ///
514    /// # 示例
515    /// ```
516    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
517    /// let mut bitmap = Bitmap::<u16>::new();
518    /// bitmap.set(5, true);
519    /// bitmap.set(10, true);
520    /// assert_eq!(bitmap.first_one(), Some(5));
521    ///
522    /// let empty_bitmap = Bitmap::<u16>::new();
523    /// assert_eq!(empty_bitmap.first_one(), None);
524    /// ```
525    #[inline]
526    pub fn first_one(&self) -> Option<usize> {
527        if self.none() {
528            None
529        } else {
530            Some(self.inner.trailing_zeros() as usize)
531        }
532    }
533}
534
535impl<T: BitStorage> BitAnd for Bitmap<T> {
536    type Output = Self;
537    /// 按位与（&）。
538    ///
539    /// # 示例
540    /// ```
541    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
542    /// let mut b1 = Bitmap::<u8>::from(0b__0000_1101); // 位 0, 2, 3 的值为 1
543    /// let mut b2 = Bitmap::<u8>::from(0b__0000_1011); // 位 0, 1, 3 的值为 1
544    /// let result = b1 & b2;
545    /// let expected = Bitmap::<u8>::from(0b__0000_1001); // 位 0, 3 的值为 1
546    /// assert_eq!(result, expected);
547    /// ```
548    fn bitand(self, rhs: Self) -> Self::Output {
549        Self {
550            inner: self.inner & rhs.inner,
551        }
552    }
553}
554
555impl<T: BitStorage> BitAndAssign for Bitmap<T> {
556    /// 按位或后赋值（&=）。
557    ///
558    /// # 示例
559    /// ```
560    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
561    /// let mut b1 = Bitmap::<u8>::from(0b__0000_1101); // 位 0, 2, 3 的值为 1
562    /// let mut b2 = Bitmap::<u8>::from(0b__0000_1011); // 位 0, 1, 3 的值为 1
563    /// b1 &= b2;
564    /// let expected = Bitmap::<u8>::from(0b__0000_1001); // 位 0, 3 的值为 1
565    /// assert_eq!(b1, expected);
566    /// ```
567    fn bitand_assign(&mut self, rhs: Self) {
568        self.inner &= rhs.inner
569    }
570}
571
572impl<T: BitStorage> BitOr for Bitmap<T> {
573    type Output = Self;
574    /// 按位或（|）。
575    ///
576    /// # 示例
577    /// ```
578    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
579    /// let mut b1 = Bitmap::<u8>::from(0b__0000_1101); // 位 0, 2, 3 的值为 1
580    /// let mut b2 = Bitmap::<u8>::from(0b__0000_1011); // 位 0, 1, 3 的值为 1
581    /// let result = b1 | b2;
582    /// let expected = Bitmap::<u8>::from(0b__0000_1111); // 位 0, 1, 2, 3 的值为 1
583    /// assert_eq!(result, expected);
584    /// ```
585    fn bitor(self, rhs: Self) -> Self::Output {
586        Self {
587            inner: self.inner | rhs.inner,
588        }
589    }
590}
591
592impl<T: BitStorage> BitOrAssign for Bitmap<T> {
593    /// 按位或后赋值（|=）。
594    ///
595    /// # 示例
596    /// ```
597    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
598    /// let mut b1 = Bitmap::<u8>::from(0b__0000_1101); // 位 0, 2, 3 的值为 1
599    /// let mut b2 = Bitmap::<u8>::from(0b__0000_1011); // 位 0, 1, 3 的值为 1
600    /// b1 |= b2;
601    /// let expected = Bitmap::<u8>::from(0b__0000_1111); // 位 0, 1, 2, 3 的值为 1
602    /// assert_eq!(b1, expected);
603    /// ```
604    fn bitor_assign(&mut self, rhs: Self) {
605        self.inner |= rhs.inner
606    }
607}
608
609impl<T: BitStorage> BitXor for Bitmap<T> {
610    type Output = Self;
611    /// 按位异或（^）
612    ///
613    /// # 示例
614    /// ```
615    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
616    /// let mut b1 = Bitmap::<u8>::from(0b__0000_1101); // 位 0, 2, 3 的值为 1
617    /// let mut b2 = Bitmap::<u8>::from(0b__0000_1011); // 位 0, 1, 3 的值为 1
618    /// let result = b1 ^ b2;
619    /// let expected = Bitmap::<u8>::from(0b__0000_0110); // 位 1, 2 的值为 1
620    /// assert_eq!(result, expected);
621    /// ```
622    fn bitxor(self, rhs: Self) -> Self::Output {
623        Self {
624            inner: self.inner ^ rhs.inner,
625        }
626    }
627}
628
629impl<T: BitStorage> BitXorAssign for Bitmap<T> {
630    /// 按位或后赋值（^=）。
631    ///
632    /// # 示例
633    /// ```
634    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
635    /// let mut b1 = Bitmap::<u8>::from(0b__0000_1101); // 位 0, 2, 3 的值为 1
636    /// let mut b2 = Bitmap::<u8>::from(0b__0000_1011); // 位 0, 1, 3 的值为 1
637    /// b1 ^= b2;
638    /// let expected = Bitmap::<u8>::from(0b__0000_0110); // 位 1, 2 的值为 1
639    /// assert_eq!(b1, expected);
640    /// ```
641    fn bitxor_assign(&mut self, rhs: Self) {
642        self.inner ^= rhs.inner
643    }
644}
645
646impl<T: BitStorage> Not for Bitmap<T> {
647    type Output = Self;
648    /// 按位取反（!）
649    ///
650    /// # 示例
651    /// ```
652    /// # use crab_vault_utils::bitmap::{Bitmap, BitStorage};
653    /// let b = Bitmap::<u8>::from(0b__1111_0000);
654    /// let result = !b;
655    /// let expected = Bitmap::<u8>::from(0b__0000_1111);
656    /// assert_eq!(result, expected);
657    /// ```
658    fn not(self) -> Self::Output {
659        Self { inner: !self.inner }
660    }
661}
crab_vault_utils/bitmap.rs

crab_vault_utils/
bitmap.rs
