Struct Bloom2 

pub struct Bloom2<H, B, T>
where
    H: BuildHasher,
    B: Bitmap,
{ /* private fields */ }

A fast, memory efficient, sparse bloom filter.

Most users can quickly initialise a Bloom2 instance by calling Bloom2::default() and start inserting anything that implements the Hash trait:

use bloom2::Bloom2;

let mut b = Bloom2::default();
b.insert(&"hello 🐐");
assert!(b.contains(&"hello 🐐"));

Initialising a Bloom2 this way uses some sensible default values for a easy-to-use, memory efficient filter. If you want to tune the probability of a false-positive lookup, change the hashing algorithm, memory size of the filter, etc, a BloomFilterBuilder can be used to initialise a Bloom2 instance with the desired properties.

The sparse nature of this filter trades a small amount of insert performance for decreased memory usage. For filters initialised infrequently and held for a meaningful duration of time, this is almost always worth the marginally increased insert latency. When testing performance, be sure to use a release build - there’s a significant performance difference!

Implementations

impl<H, B, T> Bloom2<H, B, T>

where H: BuildHasher, B: Bitmap, T: Hash,

pub fn insert(&mut self, data: &T)

Insert places data into the bloom filter.

Any subsequent calls to contains for the same data will always return true.

Insertion is significantly faster in release builds.

The data provided can be anything that implements the Hash trait, for example:

use bloom2::Bloom2;

let mut b = Bloom2::default();
b.insert(&"hello 🐐");
assert!(b.contains(&"hello 🐐"));

let mut b = Bloom2::default();
b.insert(&vec!["fox", "cat", "banana"]);
assert!(b.contains(&vec!["fox", "cat", "banana"]));

let mut b = Bloom2::default();
let data: [u8; 4] = [1, 2, 3, 42];
b.insert(&data);
assert!(b.contains(&data));

As well as structs if they implement the Hash trait, which be helpfully derived:

#[derive(Hash)]
struct User {
    id: u64,
    email: String,
}

let user = User{
    id: 42,
    email: "dom@itsallbroken.com".to_string(),
};

b.insert(&&user);
assert!(b.contains(&&user));

pub fn contains(&self, data: &T) -> bool

Checks if data exists in the filter.

If contains returns true, hash has probably been inserted previously. If contains returns false, hash has definitely not been inserted into the filter.

pub fn union(&mut self, other: &Self)

Union two Bloom2 instances (of identical configuration), returning the merged combination of both.

The returned filter will return “true” for all calls to Bloom2::contains() for all values that would return true for one (or both) of the inputs, and will return “false” for all values that return false from both inputs.

Panics

This method panics if the two Bloom2 instances have different configuration.

pub fn byte_size(&mut self) -> usize

Return the byte size of this filter.

impl<H, T> Bloom2<H, CompressedBitmap, T>

where H: BuildHasher,

pub fn shrink_to_fit(&mut self)

Minimise the memory usage of this instance by by shrinking the underlying vectors, discarding their excess capacity.

impl<H, T> Bloom2<H, VecBitmap, T>

where H: BuildHasher,

pub fn compress(self) -> Bloom2<H, CompressedBitmap, T>

Compress the bitmap to reduce memory consumption.

The compressed representation is optimised for reads, but subsequent inserts will be slower. This reduction is O(n) in time, and up to O(2n) in space.

Trait Implementations

impl<H, B, T: Clone> Clone for Bloom2<H, B, T>

where H: BuildHasher + Clone, B: Bitmap + Clone,

fn clone(&self) -> Bloom2<H, B, T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<H, B, T: Debug> Debug for Bloom2<H, B, T>

where H: BuildHasher + Debug, B: Bitmap + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for Bloom2<RandomState, CompressedBitmap, T>

where T: Hash,

Initialise a Bloom2 instance using the default implementation of BloomFilterBuilder.

It is the equivalent of:

use bloom2::BloomFilterBuilder;

let mut b = BloomFilterBuilder::default().build();

fn default() -> Self

Returns the “default value” for a type.

impl<'de, H, B, T> Deserialize<'de> for Bloom2<H, B, T>

where H: BuildHasher + Default, B: Bitmap + Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<H, T> From<Bloom2<H, VecBitmap, T>> for Bloom2<H, CompressedBitmap, T>

where H: BuildHasher,

fn from(v: Bloom2<H, VecBitmap, T>) -> Self

Converts to this type from the input type.

impl<H, B, T: PartialEq> PartialEq for Bloom2<H, B, T>

where H: BuildHasher + PartialEq, B: Bitmap + PartialEq,

fn eq(&self, other: &Bloom2<H, B, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<H, B, T> Serialize for Bloom2<H, B, T>

where H: BuildHasher, B: Bitmap + Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<H, B, T> StructuralPartialEq for Bloom2<H, B, T>

where H: BuildHasher, B: Bitmap,