Enum HExpireCond 

#[non_exhaustive]
pub enum HExpireCond {
    Always,
    Nx,
    Xx,
    Gt,
    Lt,
}

Condition flags for HEXPIRE (NX/XX/GT/LT; at most one).

assert_eq!(kevy_store::HExpireCond::default(), kevy_store::HExpireCond::Always);

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Always

Unconditional.

use kevy_store::{HExpireCond, Store};
let mut s = Store::new();
s.hset(b"h", &[(b"f".as_slice(), b"v".as_slice())])?;
let t = kevy_store::now_unix_ms() + 60_000;
assert_eq!(s.hexpire_at(b"h", &[b"f".as_slice()], t, HExpireCond::Always)?, [1]);
assert_eq!(s.hexpire_at(b"h", &[b"f".as_slice()], t + 1, HExpireCond::Always)?, [1]);

Nx

Only when the field has no TTL.

use kevy_store::{HExpireCond, Store};
let mut s = Store::new();
s.hset(b"h", &[(b"f".as_slice(), b"v".as_slice())])?;
let t = kevy_store::now_unix_ms() + 60_000;
assert_eq!(s.hexpire_at(b"h", &[b"f".as_slice()], t, HExpireCond::Nx)?, [1]);
assert_eq!(s.hexpire_at(b"h", &[b"f".as_slice()], t, HExpireCond::Nx)?, [0]);

Xx

Only when the field already has a TTL.

use kevy_store::{HExpireCond, Store};
let mut s = Store::new();
s.hset(b"h", &[(b"f".as_slice(), b"v".as_slice())])?;
let t = kevy_store::now_unix_ms() + 60_000;
assert_eq!(s.hexpire_at(b"h", &[b"f".as_slice()], t, HExpireCond::Xx)?, [0]);
s.hexpire_at(b"h", &[b"f".as_slice()], t, HExpireCond::Always)?;
assert_eq!(s.hexpire_at(b"h", &[b"f".as_slice()], t, HExpireCond::Xx)?, [1]);

Gt

Only when the new deadline is later than the current one (no TTL counts as infinitely late — GT never replaces it).

use kevy_store::{HExpireCond, Store};
let mut s = Store::new();
s.hset(b"h", &[(b"f".as_slice(), b"v".as_slice())])?;
let t = kevy_store::now_unix_ms() + 60_000;
assert_eq!(s.hexpire_at(b"h", &[b"f".as_slice()], t, HExpireCond::Gt)?, [0]);
s.hexpire_at(b"h", &[b"f".as_slice()], t, HExpireCond::Always)?;
assert_eq!(s.hexpire_at(b"h", &[b"f".as_slice()], t + 1, HExpireCond::Gt)?, [1]);

Lt

Only when the new deadline is earlier (no TTL = always).

use kevy_store::{HExpireCond, Store};
let mut s = Store::new();
s.hset(b"h", &[(b"f".as_slice(), b"v".as_slice())])?;
let t = kevy_store::now_unix_ms() + 60_000;
assert_eq!(s.hexpire_at(b"h", &[b"f".as_slice()], t, HExpireCond::Lt)?, [1]);
assert_eq!(s.hexpire_at(b"h", &[b"f".as_slice()], t + 1, HExpireCond::Lt)?, [0]);

Implementations

impl HExpireCond

pub fn keyword(self) -> Option<&'static str>

The command keyword for this condition (NX / XX / GT / LT), or None for the unconditional form, which has none.

use kevy_store::HExpireCond;
assert_eq!(HExpireCond::Gt.keyword(), Some("GT"));
assert_eq!(HExpireCond::Always.keyword(), None);

Trait Implementations

impl Clone for HExpireCond

fn clone(&self) -> HExpireCond

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for HExpireCond

impl Debug for HExpireCond

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

Formats the value using the given formatter.

impl Default for HExpireCond

fn default() -> HExpireCond

Returns the “default value” for a type.

impl Eq for HExpireCond

impl Hash for HExpireCond

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 HExpireCond

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for HExpireCond