Enum later_operator::ComparisonOperator

source ·

pub enum ComparisonOperator {
    Ne,
    Lt,
    Le,
    Eq,
    Ge,
    Gt,
}

Expand description

§Comparison Operators.

This enum holds a comparison operator — !=, <, <=, ==, >=, > — that can be used to programmatically compare two values.

Variants can be parsed from string slices using FromStr or TryFrom<&str>, or byte slices via TryFrom<&[u8]>, and converted to a string slice or byte slice using ComparisonOperator::as_str or ComparisonOperator::as_bytes respectively.

If the serde crate feature is enabled, it can also be de/serialized from/to its string representations.

Use ComparisonOperator::compare to thusly compare any two values (so long as the type implements PartialOrd).

§Examples

use later_operator::ComparisonOperator;

// Parse from a string, then compare two arbitrary values.
let op = ComparisonOperator::try_from("<=").unwrap();
assert!(op.compare(&3_u8, &u8::MAX)); // 3 <= 255

// Re-stringify the operator for printing or whatever.
assert_eq!(
    format!("3 {op} 255"),
    "3 <= 255",
);

// Leading/trailing whitespace is ignored when parsing.
assert_eq!(
    ComparisonOperator::try_from("==").unwrap(),
    ComparisonOperator::try_from(" ==\n").unwrap(),
);

// But the value has to make sense or it will fail.
assert!(ComparisonOperator::try_from("~").is_err());

When the optional serde crate feature is enabled, ComparisonOperator can be de/serialized as a string too:

use later_operator::ComparisonOperator;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Deserialize, Serialize)]
struct AffectedVersion {
    operator: ComparisonOperator,
    version: String,
}

Variants§

§

Ne

§Not Equal To.

§

Lt

§Less Than.

§

Le

§Less Than or Equal To.

§

Eq

§Equal To.

§

Ge

§Greater Than or Equal To.

§

Gt

§Greater Than.

Implementations§

source §

impl ComparisonOperator

source

pub const fn as_bytes(self) -> &'static [u8] ⓘ

§As Bytes.

Return the operator as a byte slice.

§Examples

use later_operator::ComparisonOperator;

assert_eq!(ComparisonOperator::Eq.as_bytes(), b"==");

source

pub const fn as_str(self) -> &'static str

§As Str.

Return the operator as a string slice.

§Examples

use later_operator::ComparisonOperator;

assert_eq!(ComparisonOperator::Eq.as_str(), "==");

source

pub const fn is_empty(self) -> bool

§Is Empty.

This method is added only for consistency; it always returns false.

source

pub const fn len(self) -> usize

§Length.

Return the byte length of the operator’s string representation.

source §

impl ComparisonOperator

source

pub const fn is_ne(self) -> bool

§Is Not Equal?

Returns true for ComparisonOperator::Ne.

source

pub const fn is_lt(self) -> bool

§Is Less Than?

Returns true for ComparisonOperator::Lt.

source

pub const fn is_le(self) -> bool

§Is Less Than/Equal To?

Returns true for ComparisonOperator::Le.

source

pub const fn is_eq(self) -> bool

§Is Equal?

Returns true for ComparisonOperator::Eq.

source

pub const fn is_ge(self) -> bool

§Is Greater Than/Equal To?

Returns true for ComparisonOperator::Ge.

source

pub const fn is_gt(self) -> bool

§Is Greater Than?

Returns true for ComparisonOperator::Gt.

source §

impl ComparisonOperator

source

pub fn compare<T: PartialOrd>(self, lhs: &T, rhs: &T) -> bool

§Compare.

Compare lhs to rhs using a given operator.

§Examples

use later_operator::ComparisonOperator;

let a: u32 = 50;
let b: u32 = 60;

assert_eq!(ComparisonOperator::Ne.compare(&a, &b), true);  // a != b
assert_eq!(ComparisonOperator::Lt.compare(&a, &b), true);  // a < b
assert_eq!(ComparisonOperator::Le.compare(&a, &b), true);  // a <= b
assert_eq!(ComparisonOperator::Eq.compare(&a, &b), false); // a == b
assert_eq!(ComparisonOperator::Ge.compare(&a, &b), false); // a >= b
assert_eq!(ComparisonOperator::Gt.compare(&a, &b), false); // a > b