Struct SemVer 

pub struct SemVer {
    pub major: u32,
    pub minor: u32,
    pub patch: u32,
    pub pre_rel: Option<Release>,
    pub meta: Option<String>,
}

An ideal version number that conforms to Semantic Versioning.

This is a prescriptive scheme, meaning that it follows the SemVer standard.

Legal semvers are of the form: MAJOR.MINOR.PATCH-PREREL+META

• Simple Sample: 1.2.3
• Full Sample: 1.2.3-alpha.2+a1b2c3.1

Extra Rules

1. Pre-release versions have lower precedence than normal versions.
2. Build metadata does not affect version precedence.
3. PREREL and META strings may only contain ASCII alphanumerics.

Examples

use versions::SemVer;

let orig = "1.2.3-r1+git";
let attempt = SemVer::new(orig).unwrap();

assert_eq!(orig, format!("{}", attempt));

Fields

major: u32

The major version.

minor: u32

The minor version.

patch: u32

The patch version.

pre_rel: Option<Release>

Some implies that the inner Vec of the Chunks is not empty.

meta: Option<String>

Some implies that the inner String is not empty.

Implementations

impl SemVer

pub fn new<S>(s: S) -> Option<SemVer>

where S: AsRef<str>,

Parse a SemVer from some input.

pub fn to_version(&self) -> Version

A lossless conversion from SemVer to Version.

use versions::SemVer;

let orig = "1.2.3-r1+git123";
let ver = SemVer::new(orig).unwrap().to_version();

assert_eq!("1.2.3-r1+git123", format!("{}", ver));

pub fn to_mess(&self) -> Mess

A lossless conversion from SemVer to Mess.

use versions::SemVer;

let orig = "1.2.3-r1+git123";
let mess = SemVer::new(orig).unwrap().to_mess();

assert_eq!(orig, format!("{}", mess));

pub fn parse(i: &str) -> Result<(&str, SemVer), Err<Error<&str>>>

The raw nom parser for SemVer. Feel free to use this in combination with other general nom parsers.

Trait Implementations

impl Clone for SemVer

fn clone(&self) -> SemVer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SemVer

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

Formats the value using the given formatter.

impl Default for SemVer

fn default() -> SemVer

Returns the “default value” for a type.

impl Display for SemVer

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

Formats the value using the given formatter.

impl FromStr for SemVer

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<SemVer, <SemVer as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for SemVer

For Rust, it is a Law that the following must hold:

k1 == k2 -> hash(k1) == hash(k2)

And so this is hand-implemented, since PartialEq also is.

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

where H: Hasher,

Feeds this value into the given Hasher.

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 SemVer

Build metadata does not affect version precendence, and pre-release versions have lower precedence than normal versions.

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

This method returns an Ordering between self and other.

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 SemVer

Two SemVers are equal if all fields except metadata are equal.

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

Tests for self and other values to be equal, and is used by ==.

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 SemVer

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

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

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 TryFrom<&str> for SemVer

fn try_from(value: &str) -> Result<SemVer, <SemVer as TryFrom<&str>>::Error>

use versions::SemVer;

let orig = "1.2.3";
let prsd: SemVer = orig.try_into().unwrap();
assert_eq!(orig, prsd.to_string());

type Error = Error

The type returned in the event of a conversion error.

impl Eq for SemVer