bloomz 0.1.0

A fast, flexible Bloom filter library for Rust with parallel operations support
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

#[cfg(feature = "serde")] use serde::{Serialize, Deserialize};

/// Compact fixed-size bit set storing bits in a Vec<u64>.
///
/// Used internally by the Bloom filter but can be reused for other
/// bit-indexable purposes. Indexing is zero-based.
#[derive(Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct BitSet{
    words :  Vec<u64>,
    bits : usize,
}

impl BitSet{
    /// Create a new BitSet able to hold `bits` bits, all initialized to 0.
    pub fn new(bits : usize) -> Self {
        let words = bits.div_ceil(64);
        Self { words: 
            vec![0u64; words], bits }
    }

    /// Construct directly from a words vector (length must match bits.div_ceil(64)).
    #[allow(dead_code)]
    pub(crate) fn from_words(bits: usize, words: Vec<u64>) -> Self {
        let expected = bits.div_ceil(64);
        assert_eq!(words.len(), expected, "words length mismatch for bits");
        Self { words, bits }
    }

    /// Set (turn on) the bit at global index `idx`.
    /// Panics if `idx >= self.bits`.
    pub fn set(&mut self, idx : usize){
        let word = idx/64;
        let bit = idx % 64;
        self.words[word] |= 1u64 << bit;
    }

    /// Get the value of the bit at index `idx` (true if set).
    /// Panics if `idx >= self.bits`.
    pub fn get(&self, idx : usize) -> bool {
        let word = idx/64;
        let bit = idx % 64;
        (self.words[word] >> bit) & 1u64 == 1u64
    }

    /// In-place bitwise OR with another BitSet (sizes must match).
    pub fn or_with(&mut self, other : &BitSet){
        assert_eq!(self.words.len(), other.words.len(), "bitset size mismatch");
         for (a, b) in self.words.iter_mut().zip(other.words.iter()) {
            *a |= *b;
         }
    }

    /// In-place bitwise AND with another BitSet (sizes must match).
    pub fn and_with(&mut self, other : &BitSet){
        assert_eq!(self.words.len(), other.words.len(), "bitset size mismatch");
         for (a, b) in self.words.iter_mut().zip(other.words.iter()) {
            *a &= *b;
         }
    }

    /// Clear all bits (set to 0).
    pub fn clear(&mut self) {
        self.words.fill(0);
    }

    /// Total number of addressable bits.
    pub fn len_bits(&self) -> usize {
        self.bits
    }

    /// Immutable slice of the underlying 64-bit words (little-endian bit order inside each word).
    pub fn words_slice(&self) -> &[u64] {
        &self.words
    }

    /// Mutable slice of the underlying 64-bit words (use with care).
    pub fn words_mut(&mut self) -> &mut [u64] {
        &mut self.words
    }
}