Struct version_compare::Version

pub struct Version<'a> { /* private fields */ }

Version struct, wrapping a string, providing useful comparison functions.

A version in string format can be parsed using methods like Version::from("1.2.3");, returning a Result with the parse result.

The original version string can be accessed using version.as_str(). A Version that isn’t derrived from a version string returns a generated string.

The struct provides many methods for easy comparison and probing.

Examples

use version_compare::{Version};

let ver = Version::from("1.2.3").unwrap();

Implementations

impl<'a> Version<'a>

pub fn from(version: &'a str) -> Option<Self>

Create a Version instance from a version string.

The version string should be passed to the version parameter.

Examples

use version_compare::{Cmp, Version};

let a = Version::from("1.2.3").unwrap();
let b = Version::from("1.3.0").unwrap();

assert_eq!(a.compare(b), Cmp::Lt);

pub fn from_parts(version: &'a str, parts: Vec<Part<'a>>) -> Self

Create a Version instance from already existing parts

Examples

use version_compare::{Cmp, Version, Part};

let ver = Version::from_parts("1.0", vec![Part::Number(1), Part::Number(0)]);

pub fn from_manifest(version: &'a str, manifest: &'a Manifest) -> Option<Self>

Create a Version instance from a version string with the given manifest.

The version string should be passed to the version parameter.

Examples

use version_compare::{Cmp, Version, Manifest};

let manifest = Manifest::default();
let ver = Version::from_manifest("1.2.3", &manifest).unwrap();

assert_eq!(ver.compare(Version::from("1.2.3").unwrap()), Cmp::Eq);

pub fn manifest(&self) -> Option<&Manifest>

Get the version manifest, if available.

Examples

use version_compare::Version;

let version = Version::from("1.2.3").unwrap();

if version.has_manifest() {
    println!(
        "Maximum version part depth is {} for this version",
        version.manifest().unwrap().max_depth.unwrap_or(0),
    );
} else {
    println!("Version has no manifest");
}

pub fn has_manifest(&self) -> bool

Check whether this version has a manifest.

Examples

use version_compare::Version;

let version = Version::from("1.2.3").unwrap();

if version.has_manifest() {
    println!("This version does have a manifest");
} else {
    println!("This version does not have a manifest");
}

pub fn set_manifest(&mut self, manifest: Option<&'a Manifest>)

Set the version manifest.

Examples

use version_compare::{Version, Manifest};

let manifest = Manifest::default();
let mut version = Version::from("1.2.3").unwrap();

version.set_manifest(Some(&manifest));

pub fn as_str(&self) -> &str

Get the original version string.

Examples

use version_compare::Version;

let ver = Version::from("1.2.3").unwrap();

assert_eq!(ver.as_str(), "1.2.3");

pub fn part(&self, index: usize) -> Result<Part<'a>, ()>

Get a specific version part by it’s index. An error is returned if the given index is out of bound.

Examples

use version_compare::{Version, Part};

let ver = Version::from("1.2.3").unwrap();

assert_eq!(ver.part(0), Ok(Part::Number(1)));
assert_eq!(ver.part(1), Ok(Part::Number(2)));
assert_eq!(ver.part(2), Ok(Part::Number(3)));

pub fn parts(&self) -> &[Part<'a>]

Get a vector of all version parts.

Examples

use version_compare::{Version, Part};

let ver = Version::from("1.2.3").unwrap();

assert_eq!(ver.parts(), [
    Part::Number(1),
    Part::Number(2),
    Part::Number(3)
]);

pub fn compare<V>(&self, other: V) -> Cmpwhere
    V: Borrow<Version<'a>>,

Compare this version to the given other version.

This method returns one of the following comparison operators:

• Lt
• Eq
• Gt

Other comparison operators can be used when comparing, but aren’t returned by this method.

Examples:

use version_compare::{Cmp, Version};

let a = Version::from("1.2").unwrap();
let b = Version::from("1.3.2").unwrap();

assert_eq!(a.compare(&b), Cmp::Lt);
assert_eq!(b.compare(&a), Cmp::Gt);
assert_eq!(a.compare(&a), Cmp::Eq);

pub fn compare_to<V>(&self, other: V, operator: Cmp) -> boolwhere
    V: Borrow<Version<'a>>,

Compare this version to the given other version, and check whether the given comparison operator is valid.

All comparison operators can be used.

Examples:

use version_compare::{Cmp, Version};

let a = Version::from("1.2").unwrap();
let b = Version::from("1.3.2").unwrap();

assert!(a.compare_to(&b, Cmp::Lt));
assert!(a.compare_to(&b, Cmp::Le));
assert!(a.compare_to(&a, Cmp::Eq));
assert!(a.compare_to(&a, Cmp::Le));

Trait Implementations

impl<'a> Clone for Version<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Version<'a>

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

Formats the value using the given formatter.

impl<'a> Display for Version<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq<Version<'a>> for Version<'a>

Implement the partial equality trait for the version struct, to easily allow version comparison.

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

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

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

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

impl<'a> PartialOrd<Version<'a>> for Version<'a>

Implement the partial ordering trait for the version struct, to easily allow version comparison.

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

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

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

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

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

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

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<'a> Eq for Version<'a>

impl<'a> StructuralEq for Version<'a>