Struct VersionSegment

pub struct VersionSegment<'a> {
    pub segment: &'a str,
    pub delimiters: usize,
}

This struct represents a single segment in a version string. VersionSegments are returned by the VersionSegments iterator, which is responsible for splitting a version string into its segments.

Version strings are split according to the following rules:

• Non-alphanumeric characters always count as delimiters (., -, $, etc.).

• Each segment also contains the info about the amount of leading delimiters for that segment. Leading delimiters that directly follow after one another are grouped together. The length of the delimiters is important, as it plays a crucial role in the algorithm that determines which version is newer.

  1...a would be represented as:

  [
    (segment: "1", delimiters: 0),
    (segment: "a", delimiters: 3)
  ]

• There’s no differentiation between different delimiters. '$$$' == '...' == '.$-'

• Alphanumeric strings are also split into individual sub-segments. This is done by walking over the string and splitting it every time a switch from alphabetic to numeric is detected or vice versa.

  1.1asdf123.0 would be represented as:

  [
    (segment: "1", delimiters: 0),
    (segment: "1", delimiters: 1)
    (segment: "asdf", delimiters: 0)
    (segment: "123", delimiters: 0)
    (segment: "0", delimiters: 1)
  ]

• Trailing delimiters are encoded as an empty string.

  1... would be represented as:

  [
    (segment: "1", delimiters: 0),
    (segment: "", delimiters: 3),
  ]

Fields

segment: &'a str

The string representation of the next segment

delimiters: usize

The amount of leading delimiters that were found for this segment

Implementations

impl<'a> VersionSegment<'a>

pub fn new(segment: &'a str, delimiters: usize) -> Self

Create a new instance of a VersionSegment consisting of the segment’s string and the amount of leading delimiters.

pub fn is_empty(&self) -> bool

Passhrough to self.segment.is_empty() for convenience purposes.

pub fn chars(&self) -> Chars<'a>

Passhrough to self.segment.chars() for convenience purposes.

pub fn parse<T: FromStr>(&self) -> Result<T, T::Err>

Passhrough self.segment.parse() for convenience purposes.

pub fn str_cmp(&self, other: &VersionSegment<'_>) -> Ordering

Compare the self’s segment string with segment string of other.

Trait Implementations

impl<'a> Clone for VersionSegment<'a>

fn clone(&self) -> VersionSegment<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for VersionSegment<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for VersionSegment<'a>

fn eq(&self, other: &VersionSegment<'a>) -> 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<'a> Eq for VersionSegment<'a>

impl<'a> StructuralPartialEq for VersionSegment<'a>