Enum VersionRange 

pub enum VersionRange<V> {
    Exact(V),
    Interval(Interval<V>),
    Empty,
}

A single parsed bracket interval, e.g. [1.0,2.0) or [1.0].

Generic over the ecosystem-specific bound type V (e.g. a raw version string for Maven/Gradle, or an already-parsed ParsedVersion for NuGet).

Every non-exact, satisfiable shape is a single Interval, whose fields are private: range_from_edges is the only constructor, so an inverted or zero-width-exclusive interval is unrepresentable — it collapses to VersionRange::Empty instead.

Variants

Exact(V)

[1.0] — matches only that exact version.

Interval(Interval<V>)

[1.0,2.0), [1.5,), (,2.0] — at least one bound present and the bounds admit some version.

Empty

A syntactically well-formed bounded interval that can never be satisfied by any version: min > max ([5.0,3.0]), or min == max with either bound exclusive ((3.0,3.0), [3.0,3.0)) — see #1595. Distinct from parse_interval returning None (malformed syntax): a malformed member invalidates a whole union for callers like Maven’s, while Empty is a well-formed member that legitimately contributes nothing — contains reports false for every candidate, so a requirement made up entirely of Empty members is correctly reported as unsatisfiable rather than undecidable, and an Empty member alongside valid ones in a union does not corrupt gap detection over the valid members with a fabricated edge.

Implementations

impl<V> VersionRange<V>

pub const fn upper_edge(&self) -> Bound<&V>

This range’s upper edge as a Bound — Unbounded for an open-ended-above interval and Empty (admits nothing).

Shared edge accessor for union-gap detection (deps-maven’s disjoint-range-union check, deps-composer’s OR-alternation check, #1610): both derive a member’s edges through this method instead of independently re-matching VersionRange’s variants.

Examples

use deps_core::interval::{range_from_edges, VersionRange};
use std::ops::Bound;

let cmp = |a: &String, b: &String| a.cmp(b);
let bounded = range_from_edges(
    Bound::Included("1.0".to_string()),
    Bound::Excluded("2.0".to_string()),
    cmp,
)
.unwrap();
assert_eq!(bounded.upper_edge(), Bound::Excluded(&"2.0".to_string()));

let minimum = range_from_edges(Bound::Included("1.5".to_string()), Bound::Unbounded, cmp).unwrap();
assert_eq!(minimum.upper_edge(), Bound::Unbounded);

pub const fn lower_edge(&self) -> Bound<&V>

This range’s lower edge as a Bound — Unbounded for an open-ended-below interval and Empty (admits nothing). See Self::upper_edge.

Examples

use deps_core::interval::{range_from_edges, VersionRange};
use std::ops::Bound;

let cmp = |a: &String, b: &String| a.cmp(b);
let bounded = range_from_edges(
    Bound::Included("1.0".to_string()),
    Bound::Excluded("2.0".to_string()),
    cmp,
)
.unwrap();
assert_eq!(bounded.lower_edge(), Bound::Included(&"1.0".to_string()));

let maximum = range_from_edges(Bound::Unbounded, Bound::Excluded("2.0".to_string()), cmp).unwrap();
assert_eq!(maximum.lower_edge(), Bound::Unbounded);

Trait Implementations

impl<V: Clone> Clone for VersionRange<V>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Debug> Debug for VersionRange<V>

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

Formats the value using the given formatter.

impl<V: Eq> Eq for VersionRange<V>

impl<V: PartialEq> PartialEq for VersionRange<V>

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

Equality operator ==.

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

Inequality operator !=.

impl<V: PartialEq> StructuralPartialEq for VersionRange<V>