Struct ScoreBound 

#[non_exhaustive]
pub struct ScoreBound {
    pub value: f64,
    pub exclusive: bool,
}

A score-range endpoint for ZRANGEBYSCORE/ZCOUNT (inclusive or exclusive). Use value = ±INFINITY for -inf/+inf.

use kevy_store::ScoreBound;
let lo = ScoreBound::exclusive(1.0);
assert!(lo.exclusive && lo.value == 1.0);
assert!(!ScoreBound::inclusive(f64::INFINITY).exclusive);

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.

value: f64

The score itself. f64::INFINITY / NEG_INFINITY carry +inf and -inf, which is why this is not an Option.

use kevy_store::ScoreBound;
assert_eq!(ScoreBound::inclusive(2.5).value, 2.5);
assert_eq!(ScoreBound::inclusive(f64::NEG_INFINITY).value, f64::NEG_INFINITY, "-inf");

exclusive: bool

true for Redis’s ( prefix — the endpoint is excluded from the range. An exclusive infinity is accepted and means the same as an inclusive one, since nothing equals infinity.

use kevy_store::{ScoreBound, Store};
let mut s = Store::new();
s.zadd(b"z", &[(1.0, b"a".as_slice()), (2.0, b"b")])?;
let (lo, hi) = (ScoreBound::inclusive(1.0), ScoreBound::inclusive(2.0));
assert_eq!(s.zcount(b"z", lo, hi)?, 2);
assert_eq!(s.zcount(b"z", ScoreBound::exclusive(1.0), hi)?, 1, "(1 drops a");

Implementations

impl ScoreBound

pub const fn inclusive(value: f64) -> ScoreBound

An endpoint the range includes (ZRANGEBYSCORE’s bare form).

pub const fn exclusive(value: f64) -> ScoreBound

An endpoint the range excludes (Redis’s ( prefix).

Trait Implementations

impl Clone for ScoreBound

fn clone(&self) -> ScoreBound

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ScoreBound

impl Debug for ScoreBound

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

Formats the value using the given formatter.

impl PartialEq for ScoreBound

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ScoreBound