Struct SimpleBloomFilter

pub struct SimpleBloomFilter<B, S = RandomState, V = Rc<[S]>>
where
    V: AsRef<[S]>,
{ /* private fields */ }

A Bloom filter with underlying set B and BuildHasher type S, the BuildHashers being held in a collection of type V. The supported operations are based on the traits implemented by B.

Implementations

impl<B, S, V> SimpleBloomFilter<B, S, V>

where B: BloomSet, S: BuildHasher, V: AsRef<[S]>,

pub fn new(n_hashers: usize, n_counters: usize) -> Self

where S: Default, V: FromIterator<S>,

Creates a new SimpleBloomFilter with a specified number of counters and BuildHashers. The BuildHashers will be initialized by default.

pub fn with_hashers(hashers: V, n_counters: usize) -> Self

Creates a new SimpleBloomFilter with specified BuildHashers and a specified number of counters.

pub fn into_inner(self) -> (V, B)

Returns the hashers and bit set of the filter.

pub fn hashers(&self) -> &V

Trait Implementations

impl<B, S, V> BinaryBloomFilter for SimpleBloomFilter<B, S, V>

where B: BinaryBloomSet, S: BuildHasher, V: AsRef<[S]>,

fn union<Other>(&mut self, other: &Other)

where Other: BinaryBloomFilter<Set = Self::Set, Hasher = Self::Hasher>,

Inserts all values from other into self. other and self must have the same BuildHashers for this to work, and this cannot be checked in general (for instance, RandomState does not implement PartialEq).

fn intersect<Other>(&mut self, other: &Other)

where Other: BinaryBloomFilter<Set = Self::Set, Hasher = Self::Hasher>,

Keeps only values in self which are also in other. other and self must have the same BuildHashers for this to work, and this cannot be checked in general (for instance, RandomState does not implement PartialEq).

impl<B, S, V> BloomFilter for SimpleBloomFilter<B, S, V>

where B: BloomSet, S: BuildHasher, V: AsRef<[S]>,

type Set = B

type Hasher = S

fn counters(&self) -> &B

Gets a reference to the underlying counters used by this BloomFilter.

fn insert<T: Hash>(&mut self, val: &T)

Inserts val into the set.

fn contains<T: Hash>(&self, val: &T) -> bool

Checks whether the set contains val.

fn clear(&mut self)

Clears all values from the set.

impl<B, S, V> BloomFilterDelete for SimpleBloomFilter<B, S, V>

where B: BloomSetDelete, S: BuildHasher, V: AsRef<[S]>,

fn remove<T: Hash>(&mut self, val: &T)

Removes val from the set. If val was not previously added to the set, this may cause false negatives in future queries.

impl<B: Clone, S: Clone, V> Clone for SimpleBloomFilter<B, S, V>

where V: AsRef<[S]> + Clone,

fn clone(&self) -> SimpleBloomFilter<B, S, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Debug, S: Debug, V> Debug for SimpleBloomFilter<B, S, V>

where V: AsRef<[S]> + Debug,

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

Formats the value using the given formatter.

impl<A: Hash, B, S, V> Extend<A> for SimpleBloomFilter<B, S, V>

where B: BloomSet, S: BuildHasher, V: AsRef<[S]>,

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = A>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<B: PartialEq, S: PartialEq, V> PartialEq for SimpleBloomFilter<B, S, V>

where V: AsRef<[S]> + PartialEq,

fn eq(&self, other: &SimpleBloomFilter<B, S, V>) -> 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<B, S, V> SpectralBloomFilter for SimpleBloomFilter<B, S, V>

where B: SpectralBloomSet, B::Count: Ord, S: BuildHasher, V: AsRef<[S]>,

fn contains_more_than<T: Hash>( &self, val: &T, count: &<B as SpectralBloomSet>::Count, ) -> bool

Tests whether the set contains val more than count times.

fn find_count<T: Hash>(&self, val: &T) -> &<B as SpectralBloomSet>::Count

Returns an estimate of the number of times the set contains val.

impl<B, S, V> StructuralPartialEq for SimpleBloomFilter<B, S, V>

where V: AsRef<[S]>,