Enum version_compare::comp_op::CompOp

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

Comparison operators.

Variants

Eq

Equal to. (==)

Ne

Not equal to. (!=)

Lt

Less than. (<)

Le

Less than or equal to. (<=)

Ge

Greater than or equal to. (>=)

Gt

Greater than. (>)

Implementations

impl CompOp

pub fn from_sign(sign: &str) -> Result<CompOp, ()>

Get a comparison operator by it’s sign. Whitespaces are stripped from the sign string. An error is returned if the sign isn’t recognized.

The following signs are supported:

• ==: Eq
• !=: Ne
• <: Lt
• <=: Le

• =: Ge

• : Gt

Examples

use version_compare::comp_op::CompOp;

assert_eq!(CompOp::from_sign("=="), Ok(CompOp::Eq));
assert_eq!(CompOp::from_sign("<"), Ok(CompOp::Lt));
assert_eq!(CompOp::from_sign("  >=   "), Ok(CompOp::Ge));
assert!(CompOp::from_sign("*").is_err());

pub fn from_name(sign: &str) -> Result<CompOp, ()>

Get a comparison operator by it’s name. Names are case-insensitive, and whitespaces are stripped from the string. An error is returned if the name isn’t recognized.

Examples

use version_compare::comp_op::CompOp;

assert_eq!(CompOp::from_name("eq"), Ok(CompOp::Eq));
assert_eq!(CompOp::from_name("lt"), Ok(CompOp::Lt));
assert_eq!(CompOp::from_name("  Ge   "), Ok(CompOp::Ge));
assert!(CompOp::from_name("abc").is_err());

pub fn name(&self) -> &str

Get the name of this comparison operator.

Examples

use version_compare::comp_op::CompOp;

assert_eq!(CompOp::Eq.name(), "eq");
assert_eq!(CompOp::Lt.name(), "lt");
assert_eq!(CompOp::Ge.name(), "ge");

pub fn as_inverted(self) -> Self

Covert to the inverted comparison operator.

This uses the following bidirectional rules:

• Eq <-> Ne
• Lt <-> Ge
• Le <-> Gt

Examples

use version_compare::comp_op::CompOp;

assert_eq!(CompOp::Eq.as_inverted(), CompOp::Ne);
assert_eq!(CompOp::Lt.as_inverted(), CompOp::Ge);
assert_eq!(CompOp::Gt.as_inverted(), CompOp::Le);

pub fn invert(&self) -> Self

Get the inverted comparison operator.

This uses the following bidirectional rules:

• Eq <-> Ne
• Lt <-> Ge
• Le <-> Gt

Examples

use version_compare::comp_op::CompOp;

assert_eq!(CompOp::Eq.invert(), CompOp::Ne);
assert_eq!(CompOp::Lt.invert(), CompOp::Ge);
assert_eq!(CompOp::Gt.invert(), CompOp::Le);

pub fn as_opposite(self) -> Self

Convert to the opposite comparison operator.

This uses the following bidirectional rules:

• Eq <-> Ne
• Lt <-> Gt
• Le <-> Ge

Examples

use version_compare::comp_op::CompOp;

assert_eq!(CompOp::Eq.as_opposite(), CompOp::Ne);
assert_eq!(CompOp::Lt.as_opposite(), CompOp::Gt);
assert_eq!(CompOp::Ge.as_opposite(), CompOp::Le);

pub fn opposite(&self) -> Self

Get the opposite comparison operator.

This uses the following bidirectional rules:

• Eq <-> Ne
• Lt <-> Gt
• Le <-> Ge

Examples

use version_compare::comp_op::CompOp;

assert_eq!(CompOp::Eq.opposite(), CompOp::Ne);
assert_eq!(CompOp::Lt.opposite(), CompOp::Gt);
assert_eq!(CompOp::Ge.opposite(), CompOp::Le);

pub fn as_flipped(self) -> Self

Convert to the flipped comparison operator.

This uses the following bidirectional rules:

• Lt <-> Gt
• Le <-> Ge
• Other operators are returned as is.

Examples

use version_compare::comp_op::CompOp;

assert_eq!(CompOp::Eq.as_flipped(), CompOp::Eq);
assert_eq!(CompOp::Lt.as_flipped(), CompOp::Gt);
assert_eq!(CompOp::Ge.as_flipped(), CompOp::Le);

pub fn flip(&self) -> Self

Get the flipped comparison operator.

This uses the following bidirectional rules:

• Lt <-> Gt
• Le <-> Ge
• Other operators are returned as is.

Examples

use version_compare::comp_op::CompOp;

assert_eq!(CompOp::Eq.flip(), CompOp::Eq);
assert_eq!(CompOp::Lt.flip(), CompOp::Gt);
assert_eq!(CompOp::Ge.flip(), CompOp::Le);

pub fn sign(&self) -> &'static str

Get the sign for this comparison operator.

The following signs are returned:

• Eq: ==
• Ne: !=
• Lt: <
• Le: <=
• Ge: >=
• Gt: >

Examples

use version_compare::comp_op::CompOp;

assert_eq!(CompOp::Eq.sign(), "==");
assert_eq!(CompOp::Lt.sign(), "<");
assert_eq!(CompOp::Ge.flip().sign(), "<=");

pub fn factor(&self) -> i8

Get a factor (number) for this comparison operator. These factors can be useful for quick calculations.

The following factor numbers are returned:

• Eq | Ne: 0
• Lt | Le: -1
• Gt | Ge: 1

Examples

use version_compare::version::Version;

let ver_a = Version::from("1.2.3").unwrap();
let ver_b = Version::from("1.3").unwrap();

assert_eq!(ver_a.compare(&ver_b).factor(), -1);
assert_eq!(10 * ver_b.compare(&ver_a).factor(), 10);

Trait Implementations

impl Clone for CompOp

fn clone(&self) -> CompOp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CompOp

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

Formats the value using the given formatter.

impl PartialEq<CompOp> for CompOp

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralPartialEq for CompOp