Struct pubgrub::range::Range

pub struct Range<V> { /* private fields */ }

A Range represents multiple intervals of a continuous range of monotone increasing values.

Implementations

impl<V> Range<V>

pub fn empty() -> Self

Empty set of versions.

pub fn full() -> Self

Set of all possible versions

pub fn higher_than(v: impl Into<V>) -> Self

Set of all versions higher or equal to some version

pub fn strictly_higher_than(v: impl Into<V>) -> Self

Set of all versions higher to some version

pub fn strictly_lower_than(v: impl Into<V>) -> Self

Set of all versions lower to some version

pub fn lower_than(v: impl Into<V>) -> Self

Set of all versions lower or equal to some version

pub fn between(v1: impl Into<V>, v2: impl Into<V>) -> Self

Set of versions greater or equal to v1 but less than v2.

pub fn is_empty(&self) -> bool

Whether the set is empty, i.e. it has not ranges

impl<V: Clone> Range<V>

pub fn singleton(v: impl Into<V>) -> Self

Set containing exactly one version

pub fn complement(&self) -> Self

Returns the complement of this Range.

impl<V: Ord> Range<V>

pub fn as_singleton(&self) -> Option<&V>

If the range includes a single version, return it. Otherwise, returns None.

pub fn bounding_range(&self) -> Option<(Bound<&V>, Bound<&V>)>

Convert to something that can be used with BTreeMap::range. All versions contained in self, will be in the output, but there may be versions in the output that are not contained in self. Returns None if the range is empty.

pub fn contains(&self, version: &V) -> bool

Returns true if this Range contains the specified value.

pub fn contains_many<'s, I, BV>( &'s self, versions: I ) -> impl Iterator<Item = bool> + 's

where I: Iterator<Item = BV> + 's, BV: Borrow<V> + 's,

Returns true if this Range contains the specified values.

The versions iterator must be sorted. Functionally equivalent to versions.map(|v| self.contains(v)). Except it runs in O(size_of_range + len_of_versions) not O(size_of_range * len_of_versions)

pub fn from_range_bounds<R, IV>(bounds: R) -> Self

where R: RangeBounds<IV>, IV: Clone + Into<V>,

Construct a simple range from anything that impls RangeBounds like v1..v2.

impl<V: Ord + Clone> Range<V>

pub fn union(&self, other: &Self) -> Self

Computes the union of this Range and another.

pub fn intersection(&self, other: &Self) -> Self

Computes the intersection of two sets of versions.

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

Return true if there can be no V so that V is contained in both self and other.

Note that we don’t know that set of all existing Vs here, so we only check if the segments are disjoint, not if no version is contained in both.

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

Return true if any V that is contained in self is also contained in other.

Note that we don’t know that set of all existing Vs here, so we only check if all segments self are contained in a segment of other.

pub fn simplify<'s, I, BV>(&self, versions: I) -> Self

where I: Iterator<Item = BV> + 's, BV: Borrow<V> + 's,

Returns a simpler Range that contains the same versions

For every one of the Versions provided in versions the existing range and the simplified range will agree on whether it is contained. The simplified version may include or exclude versions that are not in versions as the implementation wishes. For example:

• If all the versions are contained in the original than the range will be simplified to full.
• If none of the versions are contained in the original than the range will be simplified to empty.

If versions are not sorted the correctness of this function is not guaranteed.

pub fn iter(&self) -> impl Iterator<Item = (&Bound<V>, &Bound<V>)>

Iterate over the parts of the range.

Trait Implementations

impl<V: Clone> Clone for Range<V>

fn clone(&self) -> Range<V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Debug> Debug for Range<V>

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

Formats the value using the given formatter.

impl<V: Display + Eq> Display for Range<V>

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

Formats the value using the given formatter.

impl<V: Hash> Hash for Range<V>

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<V: PartialEq> PartialEq for Range<V>

fn eq(&self, other: &Range<V>) -> 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<T: Debug + Display + Clone + Eq + Ord> VersionSet for Range<T>

type V = T

Version type associated with the sets manipulated.

fn empty() -> Self

Constructor for an empty set containing no version.

fn singleton(v: Self::V) -> Self

Constructor for a set containing exactly one version.

fn complement(&self) -> Self

Compute the complement of this set.

fn intersection(&self, other: &Self) -> Self

Compute the intersection with another set.

fn contains(&self, v: &Self::V) -> bool

Evaluate membership of a version in this set.

fn full() -> Self

Constructor for the set containing all versions. Automatically implemented as Self::empty().complement().

fn union(&self, other: &Self) -> Self

Compute the union with another set. Thanks to set properties, this is automatically implemented as: self.complement().intersection(&other.complement()).complement()

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

Whether the range have no overlapping segmets

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

Whether all range of self are contained in other

impl<V: Eq> Eq for Range<V>

impl<V> StructuralPartialEq for Range<V>