Struct ValidUpstreamVersion 

pub struct ValidUpstreamVersion<'a>(/* private fields */);

Upstream version which has been validated.

Implementations

impl<'a> ValidUpstreamVersion<'a>

pub fn as_str(&self) -> &'a str

Get an immutable reference to the raw string underneath.

pub fn components(&self) -> UpstreamVersionComponentIter<'a>

Iterate over all components of the version.

Components are separated by dots (.), underscores (_), plus signs (+), or at signs (@). All separators are treated the same way because they are treated the same by vercmp.

Trait Implementations

impl<'a> AsRef<&'a str> for ValidUpstreamVersion<'a>

fn as_ref(&self) -> &&'a str

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Clone for ValidUpstreamVersion<'a>

fn clone(&self) -> ValidUpstreamVersion<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ValidUpstreamVersion<'a>

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

Formats the value using the given formatter.

impl<'a> Display for ValidUpstreamVersion<'a>

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

Formats the value using the given formatter.

impl<'a> From<ValidUpstreamVersion<'a>> for UpstreamVersion<'a>

fn from(value: ValidUpstreamVersion<'a>) -> Self

Converts to this type from the input type.

impl Hash for ValidUpstreamVersion<'_>

fn hash<State: Hasher>(&self, state: &mut State)

This custom hash algorithm was implemented in such a way to be consistent with ValidUpstreamVersion::cmp and ValidUpstreamVersion::eq.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for ValidUpstreamVersion<'_>

fn cmp(&self, other: &Self) -> Ordering

Comparing two validated upstream versions.

This comparison aims to emulate vercmp’s algorithm on validated upstream versions.

let validate = |raw| UpstreamVersion(raw).validate().unwrap();

// Two versions are considered equal if their internal strings are equal
assert!(validate("1.2.3") == validate("1.2.3"));
assert!(validate("1.2_3") == validate("1.2_3"));
assert!(validate("1_2_3") == validate("1_2_3"));

// Each component pair of two versions are compared until an unequal pair is found
assert!(validate("1.2.0") < validate("1.2.3"));
assert!(validate("1.3.2") > validate("1.2.3"));
assert!(validate("1.2.3.0.5.6") < validate("1.2.3.4.5.6"));
assert!(validate("1.2.3.4.5") > validate("1.2.3.2.1"));
assert!(validate("2.1.4") > validate("2.1.0.5"));
assert!(validate("1.1.0") < validate("1.2"));

// If one version is the leading part of another, the latter is considered greater
assert!(validate("1.1.0") > validate("1.1"));
assert!(validate("1.1.0") < validate("1.1.0.0"));

// The difference between dots, underscores, plus signs, and at signs are ignored
assert!(validate("1.2.3") == validate("1.2_3"));
assert!(validate("1.2.3") == validate("1_2_3"));
assert!(validate("1.2.0") < validate("1.2_3"));
assert!(validate("1_1.0") > validate("1.1"));
assert!(validate("1+2.3") == validate("1@2_3"));
assert!(validate("1@2@3") == validate("1+2+3"));
assert!(validate("1@2.0") < validate("1.2_3"));
assert!(validate("1_1.0") > validate("1+1"));

// Leading zeros are ignored
assert!(validate("01.02.3") == validate("1.2.03"));
assert!(validate("1.02.0") < validate("1.2.3"));
assert!(validate("1.01.0") > validate("1.1"));
assert!(validate("1.1.0") > validate("1.001"));

NOTE: For licensing reason, this trait method was implemented from scratch by testing case-by-case without looking at the source code of vercmp so there might be edge-cases and subtle differences. Contributors are welcomed to propose PRs to fix these edge-cases as long as they don’t look at the source code of vercmp.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for ValidUpstreamVersion<'_>

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

Return true if ValidUpstreamVersion::cmp returns Ordering::Equal. Otherwise, return false.

NOTE: Two versions being equal doesn’t necessarily means that their internal strings are equal. This is because dots (.), underscores (_), plus signs (+), and at signs (@) were ignored during parsing.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for ValidUpstreamVersion<'_>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

Return a Some(ordering) with ordering being the result of ValidUpstreamVersion::cmp.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> TryFrom<UpstreamVersion<'a>> for ValidUpstreamVersion<'a>

type Error = ValidateUpstreamVersionError<'a>

The type returned in the event of a conversion error.

fn try_from(value: UpstreamVersion<'a>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> Copy for ValidUpstreamVersion<'a>

impl Eq for ValidUpstreamVersion<'_>