Enum rustc_semver::RustcVersion

pub enum RustcVersion {
    Normal(NormalVersion),
    Special(SpecialVersion),
}

RustcVersion represents a version of the Rust Compiler.

This struct only supports the NormalVersion format

major.minor.patch

and 3 special formats represented by the SpecialVersion enum.

A version can be created with one of the functions RustcVersion::new or RustcVersion::parse. The RustcVersion::new method only supports the normal version format.

You can compare two versions, just as you would expect:

use rustc_semver::RustcVersion;

assert!(RustcVersion::new(1, 34, 0) > RustcVersion::parse("1.10").unwrap());
assert!(RustcVersion::new(1, 34, 0) > RustcVersion::parse("0.9").unwrap());

This comparison is semver conform according to the semver definition of precedence. However, if you want to check whether one version meets another version according to the Caret Requirements, you should use RustcVersion::meets.

Variants

Normal(NormalVersion)

Special(SpecialVersion)

Implementations

impl RustcVersion

pub const fn new(major: u32, minor: u32, patch: u32) -> Self

RustcVersion::new is a const constructor for a RustcVersion.

This function is primarily used to construct constants, for everything else use RustcVersion::parse.

This function only allows to construct normal versions. For special versions, construct them directly with the SpecialVersion enum.

Examples

use rustc_semver::RustcVersion;

const MY_FAVORITE_RUST: RustcVersion = RustcVersion::new(1, 48, 0);

assert!(MY_FAVORITE_RUST > RustcVersion::new(1, 0, 0))

pub fn parse(version: &str) -> Result<Self>

RustcVersion::parse parses a RustcVersion.

This function can parse all normal and special versions. It is possbile to omit parts of the version, like the patch or minor version part. So 1, 1.0, and 1.0.0 are all valid inputs and will result in the same version.

Errors

This function returns an Error, if the passed string is not a valid RustcVersion

Examples

use rustc_semver::{SpecialVersion, RustcVersion};

let ver = RustcVersion::new(1, 0, 0);

assert_eq!(RustcVersion::parse("1").unwrap(), ver);
assert_eq!(RustcVersion::parse("1.0").unwrap(), ver);
assert_eq!(RustcVersion::parse("1.0.0").unwrap(), ver);
assert_eq!(
    RustcVersion::parse("1.0.0-alpha").unwrap(),
    RustcVersion::Special(SpecialVersion::Alpha)
);

pub fn meets(self, other: Self) -> bool

RustcVersion::meets implements a semver conform version check according to the Caret Requirements.

Note that SpecialVersions only meet themself and no other version meets a SpecialVersion. This is because according to semver, special versions are considered unstable and "might not satisfy the intended compatibility requirements as denoted by [their] associated normal version".

Examples

use rustc_semver::RustcVersion;

assert!(RustcVersion::new(1, 30, 0).meets(RustcVersion::parse("1.29").unwrap()));
assert!(!RustcVersion::new(1, 30, 0).meets(RustcVersion::parse("1.31").unwrap()));

assert!(RustcVersion::new(0, 2, 1).meets(RustcVersion::parse("0.2").unwrap()));
assert!(!RustcVersion::new(0, 3, 0).meets(RustcVersion::parse("0.2").unwrap()));

Trait Implementations

impl Clone for RustcVersion

pub fn clone(&self) -> RustcVersion

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for RustcVersion

impl Debug for RustcVersion

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

Formats the value using the given formatter.

impl Display for RustcVersion

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

Formats the value using the given formatter.

impl Eq for RustcVersion

impl Ord for RustcVersion

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

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<RustcVersion> for RustcVersion

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

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

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

This method tests for !=.

impl PartialOrd<RustcVersion> for RustcVersion

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

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

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

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

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

impl StructuralEq for RustcVersion

impl StructuralPartialEq for RustcVersion