binvec 0.1.1

It is a binary vector type developed in Rust to use memory efficiently. It is characterized by using the minimum memory space to store an array of bool values.
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

use crate::Binvec;


/// An iterator over a `Binvec` that yields each bit in sequence.
///
/// The iterator maintains an internal index and returns bits one by one
/// until all bits in the `Binvec` have been iterated over.
/// 
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct BinvecIter<'a, const L: usize, const N: usize> {
    binvec: &'a Binvec<L, N>,
    index: usize,
}


impl<'a, const L: usize, const N: usize> BinvecIter<'a, L, N> {
    /// Creates a new `BinvecIter` for the given `Binvec`.
    ///
    /// ---
    /// # Parameters
    /// - `binvec`: A reference to the `Binvec` to iterate over.
    ///
    /// ---
    /// # Returns
    /// A new `BinvecIter` instance starting at the first bit.
    ///
    /// ---
    /// # Example
    /// ```
    /// use binvec::*;
    /// let binvec = binvec!(12, true);
    /// let mut iter = binvec.iter();
    /// assert_eq!(iter.next(), Some(true));
    /// ```
    /// 
    pub const fn new(binvec: &'a Binvec<L, N>) -> Self {
        Self { binvec, index: 0 }
    }
}


// impl Iterator
impl<'a, const L: usize, const N: usize> Iterator for BinvecIter<'a, L, N> {
    type Item = bool;

    fn next(&mut self) -> Option<Self::Item> {
        if self.index < L {
            // SAFETY: index is guaranteed to be less than L
            let bit: bool = unsafe { self.binvec.get_unchecked(self.index) };
            self.index += 1;
            Some(bit)
        } else {
            None
        }
    }
}