Struct BloomFilter 

pub struct BloomFilter { /* private fields */ }

Bloom filter for fast negative lookups False positive rate: ~1% with 3 hash functions

Implementations

impl BloomFilter

pub fn new(size: u32, num_hashes: u8) -> BloomFilter

Create new bloom filter with given size in bits

pub fn with_capacity(elements: usize, false_positive_rate: f64) -> BloomFilter

Create bloom filter optimized for expected number of elements Formula: size = -n * ln(p) / (ln(2)^2) Where n = elements, p = false positive rate (0.01 = 1%)

pub fn insert(&mut self, key: &[u8])

Insert key into bloom filter

pub fn contains(&self, key: &[u8]) -> bool

Check if key might exist (false positive possible, no false negative)

pub fn as_bytes(&self) -> &[u8]

Get raw bytes for serialization

pub fn from_bytes(bytes: Vec<u8>, num_hashes: u8) -> BloomFilter

Load from raw bytes

pub fn from_bytes_with_size( bytes: Vec<u8>, num_hashes: u8, size: u32, ) -> BloomFilter

Load from raw bytes with an explicit original bit size.

Use this when from_bytes would lose the declared size (when the original size was not a multiple of 8). The hash functions reduce positions modulo size, so restoring with a different value would produce false negatives.

pub fn byte_size(&self) -> usize

Get size in bytes

pub fn bit_size(&self) -> u32

Get number of bits

pub fn clear(&mut self)

Clear all bits

pub fn estimate_fp_rate(&self, inserted_count: usize) -> f64

Estimate false positive rate based on current fill

pub fn count_set_bits(&self) -> u32

Get number of set bits

pub fn fill_ratio(&self) -> f64

Calculate fill ratio (0.0 to 1.0)

pub fn merge(&self, other: &BloomFilter) -> Option<BloomFilter>

Merge two bloom filters via bitwise OR. Returns None if the filters have different size or hash count.

pub fn union_inplace(&mut self, other: &BloomFilter) -> bool

Merge another bloom filter into this one in-place. Returns false if the filters are incompatible (different size/hashes).

pub fn num_hashes(&self) -> u8

Get the number of hash functions