Enum version_compare::comp_op::CompOp [−][src]
pub enum CompOp {
Eq,
Ne,
Lt,
Le,
Ge,
Gt,
}
Expand description
Enum of supported comparison operators.
Variants
Equal (==
, =
).
When version A
is equal to B
.
Not equal (!=
, !
, <>
).
When version A
is not equal to B
.
Less than (<
).
When version A
is less than B
but not equal.
Less or equal (<=
).
When version A
is less than or equal to B
.
Greater or equal (>=
).
When version A
is greater than or equal to B
.
Greater than (>
).
When version A
is greater than B
but not equal.
Implementations
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:
==
or=
->Eq
!=
or!
or<>
->Ne
<
->Lt
<=
->Le
>=
->Ge
>
->Gt
Examples
use version_compare::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());
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::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());
Get the comparison operator from Rusts Ordering
enum.
The following comparison operators are returned:
Ordering::Less
->Lt
Ordering::Equal
->Eq
Ordering::Greater
->Gt
Get the name of this comparison operator.
Examples
use version_compare::CompOp;
assert_eq!(CompOp::Eq.name(), "eq");
assert_eq!(CompOp::Lt.name(), "lt");
assert_eq!(CompOp::Ge.name(), "ge");
Covert to the inverted comparison operator.
This uses the following bidirectional rules:
Eq
<->Ne
Lt
<->Ge
Le
<->Gt
Examples
use version_compare::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);
Get the inverted comparison operator.
This uses the following bidirectional rules:
Eq
<->Ne
Lt
<->Ge
Le
<->Gt
Examples
use version_compare::CompOp;
assert_eq!(CompOp::Eq.invert(), CompOp::Ne);
assert_eq!(CompOp::Lt.invert(), CompOp::Ge);
assert_eq!(CompOp::Gt.invert(), CompOp::Le);
Convert to the opposite comparison operator.
This uses the following bidirectional rules:
Eq
<->Ne
Lt
<->Gt
Le
<->Ge
Examples
use version_compare::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);
Get the opposite comparison operator.
This uses the following bidirectional rules:
Eq
<->Ne
Lt
<->Gt
Le
<->Ge
Examples
use version_compare::CompOp;
assert_eq!(CompOp::Eq.opposite(), CompOp::Ne);
assert_eq!(CompOp::Lt.opposite(), CompOp::Gt);
assert_eq!(CompOp::Ge.opposite(), CompOp::Le);
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::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);
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::CompOp;
assert_eq!(CompOp::Eq.flip(), CompOp::Eq);
assert_eq!(CompOp::Lt.flip(), CompOp::Gt);
assert_eq!(CompOp::Ge.flip(), CompOp::Le);
Get the sign for this comparison operator.
The following signs are returned:
Eq
->==
Ne
->!=
Lt
-><
Le
-><=
Ge
->>=
Gt
->>
Note: Some comparison operators also support other signs,
such as =
for Eq
and !
for Ne
,
these are never returned by this method however as the table above is used.
Examples
use version_compare::CompOp;
assert_eq!(CompOp::Eq.sign(), "==");
assert_eq!(CompOp::Lt.sign(), "<");
assert_eq!(CompOp::Ge.flip().sign(), "<=");
Get a factor (number) for this comparison operator. These factors can be useful for quick calculations.
The following factor numbers are returned:
Eq
orNe
->0
Lt
orLe
->-1
Gt
orGe
->1
Examples
use version_compare::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);
Get Rust’s ordering for this comparison operator.
The following comparison operators are supported:
Eq
->Ordering::Equal
Lt
->Ordering::Less
Gt
->Ordering::Greater
For other comparison operators None
is returned.
Examples
use std::cmp::Ordering;
use version_compare::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).ord().unwrap(), Ordering::Less);
Trait Implementations
Auto Trait Implementations
impl RefUnwindSafe for CompOp
impl UnwindSafe for CompOp
Blanket Implementations
Mutably borrows from an owned value. Read more