Struct abi_stable::sabi_types::version::VersionNumber

#[repr(C)]
pub struct VersionNumber {
    pub major: u32,
    pub minor: u32,
    pub patch: u32,
}

The parsed (<major>.<minor>.<patch>) version number of a library.

Post 1.0 major version

Major versions are mutually incompatible for both users and implementors.

Minor allow users to have a version less than or equal to that of the implementor, and disallows implementors from making changes that would break any previous minor release (with the same major number).

Patch cannot change the api/abi of the library at all,fixes only.

Example

use abi_stable::sabi_types::VersionNumber;

let v0_1_0 = VersionNumber {
    major: 0,
    minor: 1,
    patch: 0,
};
let v0_1_5 = VersionNumber {
    major: 0,
    minor: 1,
    patch: 5,
};
let v0_1_8 = VersionNumber {
    major: 0,
    minor: 1,
    patch: 8,
};
let v0_2_0 = VersionNumber {
    major: 0,
    minor: 2,
    patch: 0,
};

assert!(v0_1_0.is_compatible(v0_1_5), "'{}' '{}'", v0_1_0, v0_1_5);
assert!(v0_1_5.is_compatible(v0_1_8), "'{}' '{}'", v0_1_5, v0_1_8);
assert!(!v0_1_8.is_compatible(v0_2_0), "'{}' '{}'", v0_1_8, v0_2_0);

Fields

major: u32

minor: u32

patch: u32

Implementations

impl VersionNumber

pub fn new(vn: VersionStrings) -> Result<Self, ParseVersionError>

Attempts to convert a VersionStrings into a VersionNumber

Errors

This returns a ParseVersionError if the string is not correctly formatted.

Example

use abi_stable::sabi_types::{VersionNumber, VersionStrings};

static VERSION: VersionStrings = VersionStrings::new("10.5.20");

assert_eq!(
    VersionNumber::new(VERSION),
    Ok(VersionNumber {
        major: 10,
        minor: 5,
        patch: 20
    })
);

let err_version = VersionStrings::new("not a version number");
assert!(VersionNumber::new(err_version).is_err());

pub const fn is_compatible(self, library_implementor: VersionNumber) -> bool

Whether the self version number is compatible with the library_implementor version number.

This uses modified semver rules where:

• For 0.y.z ,y is interpreted as a major version, z is interpreted as the minor version,

• For x.y.z ,x>=1,y is interpreted as a minor version.

• Libraries are compatible so long as they are the same major version with a minor_version >=self.

Example

use abi_stable::sabi_types::VersionNumber;

let v0_1_0 = VersionNumber {
    major: 0,
    minor: 1,
    patch: 0,
};
let v0_1_5 = VersionNumber {
    major: 0,
    minor: 1,
    patch: 5,
};
let v0_1_8 = VersionNumber {
    major: 0,
    minor: 1,
    patch: 8,
};
let v0_2_0 = VersionNumber {
    major: 0,
    minor: 2,
    patch: 0,
};

assert!(v0_1_0.is_compatible(v0_1_5), "'{}' '{}'", v0_1_0, v0_1_5);
assert!(v0_1_5.is_compatible(v0_1_8), "'{}' '{}'", v0_1_5, v0_1_8);
assert!(!v0_1_8.is_compatible(v0_2_0), "'{}' '{}'", v0_1_8, v0_2_0);

pub const fn is_loosely_compatible( self, library_implementor: VersionNumber, ) -> bool

Whether the self version number is compatible with the library version number.

This uses the same semver rules as cargo:

• For 0.y.z ,y is interpreted as a major version, z is interpreted as the minor version,

• For x.y.z ,x>=1,y is interpreted as a minor version.

• Libraries are compatible so long as they are the same major version irrespective of their minor version.

Example

use abi_stable::sabi_types::VersionNumber;

let v0_1_0 = VersionNumber {
    major: 0,
    minor: 1,
    patch: 0,
};
let v0_1_5 = VersionNumber {
    major: 0,
    minor: 1,
    patch: 5,
};
let v0_1_8 = VersionNumber {
    major: 0,
    minor: 1,
    patch: 8,
};
let v0_2_0 = VersionNumber {
    major: 0,
    minor: 2,
    patch: 0,
};
let v0_2_8 = VersionNumber {
    major: 0,
    minor: 2,
    patch: 8,
};
let v1_0_0 = VersionNumber {
    major: 1,
    minor: 0,
    patch: 0,
};
let v1_5_0 = VersionNumber {
    major: 1,
    minor: 5,
    patch: 0,
};
let v2_0_0 = VersionNumber {
    major: 2,
    minor: 0,
    patch: 0,
};

fn is_compat_assert(l: VersionNumber, r: VersionNumber, are_they_compat: bool) {
    assert_eq!(l.is_loosely_compatible(r), are_they_compat);
    assert_eq!(r.is_loosely_compatible(l), are_they_compat);
}

is_compat_assert(v0_1_0, v0_1_5, true);
is_compat_assert(v0_1_5, v0_1_8, true);
is_compat_assert(v1_0_0, v1_5_0, true);
is_compat_assert(v0_1_8, v0_2_0, false);
is_compat_assert(v0_2_8, v1_0_0, false);
is_compat_assert(v2_0_0, v1_0_0, false);
is_compat_assert(v2_0_0, v1_5_0, false);

Trait Implementations

impl Clone for VersionNumber

fn clone(&self) -> VersionNumber

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for VersionNumber

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

Formats the value using the given formatter.

impl Display for VersionNumber

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

Formats the value using the given formatter.

impl GetStaticEquivalent_ for VersionNumber

type StaticEquivalent = _static_VersionNumber

The 'static equivalent of Self

impl PartialEq for VersionNumber

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

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern.

const LAYOUT: &'static TypeLayout = _

The layout of the type provided by implementors.

const ABI_CONSTS: AbiConsts = _

const-equivalents of the associated types.

impl Copy for VersionNumber

impl Eq for VersionNumber

impl StructuralPartialEq for VersionNumber