Struct Version 

pub struct Version {
    pub epoch: Option<u32>,
    pub upstream_version: String,
    pub debian_revision: Option<String>,
}

A Debian version string

Fields

epoch: Option<u32>

The epoch of the version, if any

upstream_version: String

The upstream version

debian_revision: Option<String>

The Debian revision, if any

Implementations

impl Version

pub fn parse_lenient(text: &str) -> Result<Version, ParseError>

Parse a version string with lenient parsing rules.

This method accepts version strings that may not strictly comply with Debian Policy, such as versions containing underscores. While the standard FromStr implementation enforces strict Debian Policy compliance, this method is more permissive to handle real-world packages that may use non-standard characters.

Examples

use debversion::Version;
// This version contains underscores, which violates Debian Policy
// but may appear in real-world packages
let v = Version::parse_lenient("2.0.37+cvs.JCW_PRE2_2037-1").unwrap();
assert_eq!(v.upstream_version, "2.0.37+cvs.JCW_PRE2_2037");
assert_eq!(v.debian_revision, Some("1".to_string()));

pub fn is_bin_nmu(&self) -> bool

Is this a binNMU?

A binNMU is a binary-only NMU (Non-Maintainer Upload) where the source package is not changed.

Note that this checks for the presence of the +b[:digit:] suffix, which is not part of the Debian Policy Manual, but it is commonly used to indicate a binNMU.

Examples

use debversion::Version;
assert!("1.0+b1".parse::<Version>().unwrap().is_bin_nmu());
assert!("1.0-1+b1".parse::<Version>().unwrap().is_bin_nmu());
assert!(!"1.0-1".parse::<Version>().unwrap().is_bin_nmu());
assert!(!"1.0".parse::<Version>().unwrap().is_bin_nmu());

pub fn bin_nmu_count(&self) -> Option<i32>

Return the binNMU count of this version

This will return the binNMU count of this version, or None if this is not a binNMU.

pub fn increment_bin_nmu(self) -> Version

Create a binNMU version from this version

This will increment the binNMU suffix by one, or add a +b1 suffix if there is no binNMU suffix.

pub fn is_nmu(&self) -> bool

Check if this version is a sourceful NMU

A sourceful NMU is a Non-Maintainer Upload where the source package is changed. This is indicated by the presence of a +nmu[:digit:] suffix. This is not part of the Debian Policy Manual, but it is commonly used to indicate a sourceful NMU.

pub fn nmu_count(&self) -> Option<i32>

Return the sourceful NMU count of this version

This will return the sourceful NMU count of this version, or None if this is not a sourceful NMU.

pub fn canonicalize(&self) -> Version

Return canonicalized version of this version

Examples

use debversion::Version;
assert_eq!("1.0-0".parse::<Version>().unwrap().canonicalize(), "1.0".parse::<Version>().unwrap());
assert_eq!("1.0-1".parse::<Version>().unwrap().canonicalize(), "1.0-1".parse::<Version>().unwrap());

pub fn increment_debian(&mut self)

Increment the Debian revision.

For native packages, increment the upstream version number. For other packages, increment the debian revision.

pub fn is_native(&self) -> bool

Return true if this is a native package

Trait Implementations

impl AsVersion for Version

fn into_version(self) -> Result<Version, ParseError>

Convert the argument into a Version

impl Clone for Version

fn clone(&self) -> Version

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Version

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Version

Available on crate feature serde only.

fn deserialize<D>( deserializer: D, ) -> Result<Version, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Version

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

Formats the value using the given formatter.

impl FromPyObject<'_, '_> for Version

Available on crate feature python-debian only.

type Error = PyErr

The type returned in the event of a conversion error.

fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Version, PyErr>

Extracts Self from the bound smart pointer obj.

impl FromStr for Version

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(text: &str) -> Result<Version, <Version as FromStr>::Err>

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

impl Hash for Version

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<'py> IntoPyObject<'py> for Version

Available on crate feature python-debian only.

type Target = PyAny

The Python output type

type Output = Bound<'py, <Version as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Version as IntoPyObject<'py>>::Output, <Version as IntoPyObject<'py>>::Error>

Performs the conversion.

impl Ord for Version

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

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

fn partial_cmp(&self, other: &Version) -> 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 Serialize for Version

Available on crate feature serde only.

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Version