Struct pearl::filter::bloom::Bloom

pub struct Bloom { /* fields omitted */ }

Bloom filter

Implementations

impl Bloom

pub fn new(config: Config) -> Self

Create new bloom filter

pub fn checked_add_assign(&mut self, other: &Bloom) -> bool

Merge filters

pub fn clear(&mut self)

Set in-memory filter buffer to zeroed array

pub fn is_offloaded(&self) -> bool

Check if filter offloaded

pub fn offload_from_memory(&mut self) -> usize

Clear in-memory filter buffer

pub fn to_raw(&self) -> Result<Vec<u8>>

Serialize filter to bytes

pub fn from_raw(buf: &[u8]) -> Result<Self>

Deserialize filter from bytes

pub fn add(&mut self, item: impl AsRef<[u8]>) -> Result<()>

Add value to filter

pub fn contains_in_memory(&self, item: impl AsRef<[u8]>) -> Option<FilterResult>

Check filter in-memory (if not offloaded)

pub async fn contains_in_file<P: BloomDataProvider>(
    &self,
    provider: &P,
    item: impl AsRef<[u8]>
) -> Result<FilterResult>

Check filter by reading bits from file

pub fn memory_allocated(&self) -> usize

Get amount of memory allocated for filter

Trait Implementations

impl Clone for Bloom

fn clone(&self) -> Bloom

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Bloom

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

Formats the value using the given formatter.

impl Default for Bloom

fn default() -> Self

Returns the “default value” for a type.

impl<K> FilterTrait<K> for Bloom where
    K: AsRef<[u8]> + Sync + Send, 

fn add(&mut self, key: &K)

Add key to filter

fn contains_fast(&self, key: &K) -> FilterResult

Check if key in filter (should be implemented if filter can be checked without waiting)

fn contains<'life0, 'life1, 'life2, 'async_trait, P: BloomDataProvider>(
    &'life0 self,
    provider: &'life1 P,
    key: &'life2 K
) -> Pin<Box<dyn Future<Output = FilterResult> + Send + 'async_trait>> where
    P: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Check if key in filter (can take some time)

fn offload_filter(&mut self) -> usize

Offload filter from memory if possible

fn checked_add_assign(&mut self, other: &Self) -> bool

Add another filter to this filter

fn memory_allocated(&self) -> usize

Memory used by filter