Enum versions::Versioning

pub enum Versioning {
    Ideal(SemVer),
    General(Version),
    Complex(Mess),
}

A top-level Versioning type which acts as a wrapper for the more specific types.

Examples

use versions::Versioning;

let a = Versioning::new("1.2.3-1").unwrap();   // SemVer.
let b = Versioning::new("1.2.3r1").unwrap();   // Not SemVer but good enough.
let c = Versioning::new("000.007-1").unwrap(); // Garbage.

assert!(a.is_ideal());
assert!(b.is_general());
assert!(c.is_complex());

Variants

Ideal(SemVer)

Follows good parsing and comparison rules.

General(Version)

A little more permissive than SemVer.

Complex(Mess)

Hope that you need not venture here.

Implementations

impl Versioning

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

where S: AsRef<str>,

Create a Versioning by attempting to parse the input first as SemVer, then as a Version, and finally as a Mess.

pub fn parse(i: &str) -> IResult<&str, Versioning>

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

pub fn is_ideal(&self) -> bool

A short-hand for detecting an inner SemVer.

pub fn is_general(&self) -> bool

A short-hand for detecting an inner Version.

pub fn is_complex(&self) -> bool

A short-hand for detecting an inner Mess.

pub fn nth(&self, n: usize) -> Option<u32>

Try to extract a position from the Versioning as a nice integer, as if it were a SemVer.

use versions::Versioning;

let semver = Versioning::new("1.2.3-r1+git123").unwrap();
assert!(semver.is_ideal());
assert_eq!(Some(1), semver.nth(0));
assert_eq!(Some(2), semver.nth(1));
assert_eq!(Some(3), semver.nth(2));

let version = Versioning::new("1:2.a.4.5.6.7-r1").unwrap();
assert!(version.is_general());
assert_eq!(Some(2), version.nth(0));
assert_eq!(None, version.nth(1));
assert_eq!(Some(4), version.nth(2));

let mess = Versioning::new("1.6a.0+2014+m872b87e73dfb-1").unwrap();
assert!(mess.is_complex());
assert_eq!(Some(1), mess.nth(0));
assert_eq!(None, mess.nth(1));
assert_eq!(Some(0), mess.nth(2));

Trait Implementations

impl Clone for Versioning

fn clone(&self) -> Versioning

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Versioning

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

Formats the value using the given formatter.

impl Default for Versioning

fn default() -> Self

Returns the “default value” for a type.

impl Display for Versioning

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

Formats the value using the given formatter.

impl FromStr for Versioning

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

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

impl Hash for Versioning

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

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 Versioning

fn cmp(&self, other: &Self) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Versioning

fn eq(&self, other: &Versioning) -> 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 Versioning

fn partial_cmp(&self, other: &Self) -> 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 Versioning

fn try_from(value: &str) -> Result<Self, Self::Error>

use versions::Versioning;

let orig = "1.2.3";
let prsd: Versioning = 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 Versioning

impl StructuralPartialEq for Versioning