Struct ExpireStats 

#[non_exhaustive]
pub struct ExpireStats {
    pub sampled: u32,
    pub expired: u32,
    pub rounds: u32,
}

What Store::tick_expire saw and did. Surfaced for tests, INFO keyspace, and (eventually) Wave 2 task #4’s crash-safe verifier.

use kevy_store::{ExpireStats, Store};
let mut s = Store::new();
// no TTL-bearing keys: the reaper does no work at all
assert_eq!(s.tick_expire(16, 16), ExpireStats::default());

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

sampled: u32

Total TTL-bearing keys sampled across all rounds.

use core::time::Duration;
use kevy_store::{SetCondition, Store};
let mut s = Store::new();
s.set(b"live", b"v".to_vec(), Some(Duration::from_secs(60)), SetCondition::Always);
// the walk starts at a random bucket, so one key may or may not be seen
let stats = s.tick_expire(16, 1);
assert!(stats.sampled <= 1);
assert_eq!(stats.expired, 0);

expired: u32

How many of those were past their deadline and got removed.

use core::time::Duration;
use kevy_store::{SetCondition, Store};
let mut s = Store::new();
for k in [b"a", b"b"] {
    s.set(k, b"v".to_vec(), Some(Duration::from_millis(1)), SetCondition::Always);
}
let mut expired = 0;
for _ in 0..500 {
    expired += s.tick_expire(16, 16).expired;
    if s.dbsize() == 0 {
        break;
    }
    std::thread::sleep(Duration::from_millis(2));
}
assert_eq!(expired, 2);

rounds: u32

Rounds executed before the loop exited (either max_rounds reached or in-batch expire-rate dropped below the continuation threshold).

use core::time::Duration;
use kevy_store::{SetCondition, Store};
let mut s = Store::new();
s.set(b"live", b"v".to_vec(), Some(Duration::from_secs(60)), SetCondition::Always);
// nothing is due, so the tick stops well short of its 8-round budget
let stats = s.tick_expire(16, 8);
assert!((1..=3).contains(&stats.rounds));

Trait Implementations

impl Clone for ExpireStats

fn clone(&self) -> ExpireStats

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ExpireStats

impl Debug for ExpireStats

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

Formats the value using the given formatter.

impl Default for ExpireStats

fn default() -> ExpireStats

Returns the “default value” for a type.

impl Eq for ExpireStats

impl Hash for ExpireStats

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ExpireStats

fn eq(&self, other: &ExpireStats) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ExpireStats