Enum Version

Source

pub enum Version {
    Base(BaseVersion),
    Full(FullVersion),
}

Expand description

A numbered version which is a two-component major.minor version number, or a three-component major.minor.patch version number.

Variants§

§

Base(BaseVersion)

A two-component major.minor version.

§

Full(FullVersion)

A three-component major.minor.patch version.

Implementations§

Source §

impl Version

Source

pub fn parse(input: &str) -> Result<Self, Error>

Parse a two- or three-component, major.minor or major.minor.patch respectively, version number from a given input.

Returns a Error::ParserError if it fails to parse.

Source

pub fn new_base_version(major: u64, minor: u64) -> Self

Create a new two-component major.minor version number.

Source

pub fn new_full_version(major: u64, minor: u64, patch: u64) -> Self

Create a new three-component major.minor.patch version number.

Source

pub fn major(&self) -> u64

Returns the major version component.

Both the two- and three-component version number variants have a major version. This is the leading component.

Source

pub fn minor(&self) -> u64

Returns the minor version component.

Both the two- and three-component version number variants have a minor version. This is the middle component.

Source

pub fn patch(&self) -> Option<u64>

Returns the patch version component, if any.

A three component major.minor.patch version will return a Some(<version>), while a two component major.minor version will return None instead.

If it exists, it is the last component.

Source

pub fn is(&self, variant: Variant) -> bool

Check of which variant self is.

Source

pub fn map<U, F>(self, fun: F) -> U
where F: FnOnce(Self) -> U,

Map a Version to U.

§Example

use version_number::{BaseVersion, FullVersion, Version};

// 🧑‍🔬
fn invert_version(v: Version) -> Version {
    match v {
        Version::Base(base) => Version::Base(BaseVersion::new(base.minor, base.major)),
        Version::Full(full) => Version::Full(FullVersion::new(full.patch, full.minor, full.major))
    }
}

let base_example = Version::Base(BaseVersion::new(1, 2));
let full_example = Version::Full(FullVersion::new(1, 2, 3));

assert_eq!(base_example.map(invert_version), Version::Base(BaseVersion::new(2, 1)));
assert_eq!(full_example.map(invert_version), Version::Full(FullVersion::new(3, 2, 1)));

Source

pub fn map_major<F>(self, fun: F) -> Self
where F: FnOnce(u64) -> u64,

Map over the major version component of the Version.

§Example

use version_number::{BaseVersion, FullVersion, Version};

let base_example = Version::Base(BaseVersion::new(0, 0));
let full_example = Version::Full(FullVersion::new(0, 0, 0));

assert_eq!(base_example.map_major(|a| a + 1), Version::Base(BaseVersion::new(1, 0)));
assert_eq!(full_example.map_major(|a| a + 1), Version::Full(FullVersion::new(1, 0, 0)));

Source

pub fn map_minor<F>(self, fun: F) -> Self
where F: FnOnce(u64) -> u64,

Map over the minor version component of the Version.

§Example

use version_number::{BaseVersion, FullVersion, Version};

let base_example = Version::Base(BaseVersion::new(0, 0));
let full_example = Version::Full(FullVersion::new(0, 0, 0));

assert_eq!(base_example.map_minor(|a| a + 1), Version::Base(BaseVersion::new(0, 1)));
assert_eq!(full_example.map_minor(|a| a + 1), Version::Full(FullVersion::new(0, 1, 0)));

Source

pub fn map_patch<F>(self, fun: F) -> Self
where F: FnOnce(u64) -> u64,

Map over the patch version component of the Version. If no patch version exists (in case the Version consists of two components), then the original version is returned.

§Example

use version_number::{BaseVersion, FullVersion, Version};

let base_example = Version::Base(BaseVersion::new(0, 0));
let full_example = Version::Full(FullVersion::new(0, 0, 0));

assert_eq!(base_example.map_patch(|a| a + 1), Version::Base(BaseVersion::new(0, 0)));
assert_eq!(full_example.map_patch(|a| a + 1), Version::Full(FullVersion::new(0, 0, 1)));