Struct semver::VersionReq

pub struct VersionReq {
    pub comparators: Vec<Comparator>,
}

SemVer version requirement describing the intersection of some version comparators, such as >=1.2.3, <1.8.

Syntax

• Either * (meaning “any”), or one or more comma-separated comparators.

• A Comparator is an operator (Op) and a partial version, separated by optional whitespace. For example >=1.0.0 or >=1.0.

• Build metadata is syntactically permitted on the partial versions, but is completely ignored, as it’s never relevant to whether any comparator matches a particular version.

• Whitespace is permitted around commas and around operators. Whitespace is not permitted within a partial version, i.e. anywhere between the major version number and its minor, patch, pre-release, or build metadata.

Fields

comparators: Vec<Comparator>

Implementations

impl VersionReq

pub const STAR: Self = _

A VersionReq with no constraint on the version numbers it matches. Equivalent to VersionReq::parse("*").unwrap().

In terms of comparators this is equivalent to >=0.0.0.

Counterintuitively a * VersionReq does not match every possible version number. In particular, in order for any VersionReq to match a pre-release version, the VersionReq must contain at least one Comparator that has an explicit major, minor, and patch version identical to the pre-release being matched, and that has a nonempty pre-release component. Since * is not written with an explicit major, minor, and patch version, and does not contain a nonempty pre-release component, it does not match any pre-release versions.

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

Create VersionReq by parsing from string representation.

Errors

Possible reasons for the parse to fail include:

• >a.b — unexpected characters in the partial version.

• @1.0.0 — unrecognized comparison operator.

• ^1.0.0, — unexpected end of input.

• >=1.0 <2.0 — missing comma between comparators.

• *.* — unsupported wildcard syntax.

pub fn matches(&self, version: &Version) -> bool

Evaluate whether the given Version satisfies the version requirement described by self.

Trait Implementations

impl Clone for VersionReq

fn clone(&self) -> VersionReq

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for VersionReq

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

Formats the value using the given formatter.

impl Default for VersionReq

The default VersionReq is the same as VersionReq::STAR.

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for VersionReq

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for VersionReq

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

Formats the value using the given formatter.

impl FromIterator<Comparator> for VersionReq

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = Comparator>,

Creates a value from an iterator.

impl FromStr for VersionReq

type Err = Error

The associated error which can be returned from parsing.

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

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

impl Hash for VersionReq

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 PartialEq for VersionReq

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

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for VersionReq

impl StructuralPartialEq for VersionReq