Struct ExpiringAtomicFilter 

pub struct ExpiringAtomicFilter<H = DefaultHasher>
where
    H: Hasher + Default,
{
    pub ttl: u64,
    pub expiration_period: u64,
    pub created: u64,
    /* private fields */
}

A serializable approximate membership query filter supporting lock-free concurrency and time-based expiration.

Fields

ttl: u64

Number of seconds each item is expected to remain in the filter. Items may remain up to ttl + expiration_period, but no longer than that. Must be a multiple of expiration_period.

expiration_period: u64

Maximum number of seconds between expiration events.

created: u64

Unix timestamp of when the filter was created. Needed to determine which slot in the buffer is selected for insert, lock, and expire operations.

Implementations

impl<H> ExpiringAtomicFilter<H>

where H: Hasher + Default,

pub fn insert<T: ?Sized + Hash>(&self, item: &T) -> Result<(), Error>

Insert an item into the filter.

Returns Ok(()) if the item was inserted, or Error::NotEnoughSpace if the filter is full.

https://docs.rs/atomic-cuckoo-filter/*/atomic_cuckoo_filter/struct.CuckooFilter.html#method.insert

pub fn insert_unique<T: ?Sized + Hash>(&self, item: &T) -> Result<bool, Error>

Check if an item is in the filter and insert it if is not present (atomically).

Returns Ok(true) if the item was inserted, Ok(false) if it was already present, or Error::NotEnoughSpace if the filter is full.

https://docs.rs/atomic-cuckoo-filter/*/atomic_cuckoo_filter/struct.CuckooFilter.html#method.insert_unique

pub fn count<T: ?Sized + Hash>(&self, item: &T) -> usize

Counts the number of occurrences of an item in the filter.

https://docs.rs/atomic-cuckoo-filter/*/atomic_cuckoo_filter/struct.CuckooFilter.html#method.count

pub fn remove<T: ?Sized + Hash>(&self, item: &T) -> bool

Attempts to remove an item from the filter.

Returns true if the item was successfully removed, or false if it was not found.

https://docs.rs/atomic-cuckoo-filter/*/atomic_cuckoo_filter/struct.CuckooFilter.html#method.remove

pub fn contains<T: ?Sized + Hash>(&self, item: &T) -> bool

Check if an item is in the filter.

Returns true if the item is possibly in the filter (may have false positives), false if it is definitely not in the filter.

https://docs.rs/atomic-cuckoo-filter/*/atomic_cuckoo_filter/struct.CuckooFilter.html#method.contains

pub fn len(&self) -> usize

Get the number of elements in the filter.

pub fn is_empty(&self) -> bool

Check if the filter is empty.

pub fn capacity(&self) -> usize

Get the capacity of the filter.

pub fn clear(&self)

Clear the filter, removing all elements.

pub fn lock(&self, kind: LockKind) -> Option<Lock<'_>>

Acquires a lock on the filter, if necessary.

Returns Some(Lock) if a lock is needed, or None if no locking is required.

https://docs.rs/atomic-cuckoo-filter/*/atomic_cuckoo_filter/struct.CuckooFilter.html#method.lock

pub fn expire(&self) -> usize

Returns the number of items that were removed.

pub fn expire_as_of(&self, now: u64) -> usize

Returns the number of items that were removed.

impl ExpiringAtomicFilter<DefaultHasher>

pub fn builder() -> ExpiringAtomicFilterBuilder<DefaultHasher>

Create a new ExpiringAtomicFilterBuilder with default settings

pub fn new() -> ExpiringAtomicFilter<DefaultHasher>

Create a new ExpiringAtomicFilter with default settings

pub fn with_capacity(capacity: usize) -> ExpiringAtomicFilter<DefaultHasher>

Create a new ExpiringAtomicFilter with the specified capacity

Trait Implementations

impl<H> Debug for ExpiringAtomicFilter<H>

where H: Hasher + Default + Debug,

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

Formats the value using the given formatter.

impl Default for ExpiringAtomicFilter<DefaultHasher>

fn default() -> Self

Create a new CuckooFilter with default settings

impl<'de, H> Deserialize<'de> for ExpiringAtomicFilter<H>

where H: Hasher + Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<H> Serialize for ExpiringAtomicFilter<H>

where H: Hasher + Default,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.