Enum version_compare::comp_op::CompOp
[−]
[src]
pub enum CompOp { Eq, Ne, Lt, Le, Ge, Gt, }
Enum of supported comparison operators.
Variants
Eq
Equal (==
).
When version A
is equal to B
.
Ne
Not equal (!=
).
When version A
is not equal to B
.
Lt
Less than (<
).
When version A
is less than B
but not equal.
Le
Less or equal (<=
).
When version A
is less than or equal to B
.
Ge
Greater or equal (>=
).
When version A
is greater than or equal to B
.
Gt
Greater than (>
).
When version A
is greater than B
but not equal.
Methods
impl CompOp
[src]
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::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());
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::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());
fn from_ord(ord: Ordering) -> CompOp
Get the comparison operator from Rusts Ordering
enum.
The following comparison operators are returned:
Ordering::Less
->Lt
Ordering::Equal
->Eq
Ordering::Greater
->Gt
fn name(&self) -> &str
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");
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::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);
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::CompOp; assert_eq!(CompOp::Eq.invert(), CompOp::Ne); assert_eq!(CompOp::Lt.invert(), CompOp::Ge); assert_eq!(CompOp::Gt.invert(), CompOp::Le);
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::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);
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::CompOp; assert_eq!(CompOp::Eq.opposite(), CompOp::Ne); assert_eq!(CompOp::Lt.opposite(), CompOp::Gt); assert_eq!(CompOp::Ge.opposite(), CompOp::Le);
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::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);
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::CompOp; assert_eq!(CompOp::Eq.flip(), CompOp::Eq); assert_eq!(CompOp::Lt.flip(), CompOp::Gt); assert_eq!(CompOp::Ge.flip(), CompOp::Le);
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::CompOp; assert_eq!(CompOp::Eq.sign(), "=="); assert_eq!(CompOp::Lt.sign(), "<"); assert_eq!(CompOp::Ge.flip().sign(), "<=");
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
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);
fn ord(&self) -> Option<Ordering>
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
impl Debug for CompOp
[src]
impl Clone for CompOp
[src]
fn clone(&self) -> CompOp
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0
Performs copy-assignment from source
. Read more