Struct BloomFilter 

pub struct BloomFilter { /* private fields */ }

Bloom filter for fast probabilistic existence checks.

Uses multiple hash functions to minimize false positives while maintaining constant-time lookups regardless of dataset size.

Implementations

impl BloomFilter

pub fn new(expected_items: usize, false_positive_rate: f64) -> Self

Create a new bloom filter with the given expected item count and false positive rate.

Arguments

• expected_items - Expected number of items to be stored
• false_positive_rate - Desired false positive rate (0.0 - 1.0)

pub fn with_config(config: BloomConfig) -> Self

Create a bloom filter with custom configuration

pub fn insert_cid(&self, cid: &Cid)

Insert a CID into the bloom filter

pub fn contains_cid(&self, cid: &Cid) -> bool

Check if a CID might be in the bloom filter

Returns true if the CID might be present (may be a false positive), Returns false if the CID is definitely not present.

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

Insert raw bytes into the bloom filter

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

Check if raw bytes might be in the bloom filter

pub fn count(&self) -> usize

Get the number of items inserted

pub fn fill_ratio(&self) -> f64

Get the fill ratio (proportion of bits set)

pub fn estimated_fpr(&self) -> f64

Estimate the actual false positive rate based on current fill

pub fn memory_bytes(&self) -> usize

Get memory usage in bytes

pub fn clear(&self)

Clear the bloom filter

pub fn save_to_file(&self, path: &Path) -> Result<()>

Save the bloom filter to a file

pub fn load_from_file(path: &Path, config: BloomConfig) -> Result<Self>

Load the bloom filter from a file

pub fn stats(&self) -> BloomStats

Get bloom filter statistics

impl BloomFilter

Convenience constructor: create a BloomFilter backed by a fixed bit-count.

Rounds bits up to the next multiple of 64 and uses a two-hash (FNV-1a + multiplicative) scheme with 7 probes — chosen for ~1 % FPR at 100 k elements in a 1 M-bit filter.

pub fn new_with_bits(bits: usize) -> Self

Create a filter with exactly bits capacity (rounded up to 64-bit boundary).

Uses a fixed 7-probe two-hash scheme suitable for general-purpose deduplication.

pub fn len(&self) -> usize

Number of elements inserted so far (alias for count()).

pub fn is_empty(&self) -> bool

Whether no elements have been inserted.

pub fn is_bloom_empty(&self) -> bool

Whether no elements have been inserted (semantic alias, kept for test clarity).

pub fn bit_count(&self) -> usize

Total number of bits in the filter.

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

Probabilistic check: returns false iff the key is definitely absent.

pub fn estimated_fill_ratio(&self) -> f64

Fraction of bits currently set (0.0 – 1.0).