1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
use std::cmp::Ordering;
use std::ops::RangeInclusive;
/// Version strings can be broken up into Parts.
/// One Part represents either a string of digits or characters.
/// '.' and '_' represent deviders between parts and are not included in any part.
#[derive(PartialEq, Eq, Clone, Debug)]
pub enum VersionPart<'a> {
Word(&'a str),
Number(&'a str),
}
impl PartialOrd for VersionPart<'_> {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl Ord for VersionPart<'_> {
fn cmp(self: &Self, other: &Self) -> Ordering {
match (self, other) {
(VersionPart::Number(s1), VersionPart::Number(s2)) => {
// Note: C++ Nix uses `int`, but probably doesn't make a difference
// We trust that the splitting was done correctly and parsing will work
let n1: u64 = s1.parse().unwrap();
let n2: u64 = s2.parse().unwrap();
n1.cmp(&n2)
}
// empty Word always looses
(VersionPart::Word(""), VersionPart::Number(_)) => Ordering::Less,
(VersionPart::Number(_), VersionPart::Word("")) => Ordering::Greater,
// `pre` looses unless the other part is also a `pre`
(VersionPart::Word("pre"), VersionPart::Word("pre")) => Ordering::Equal,
(VersionPart::Word("pre"), _) => Ordering::Less,
(_, VersionPart::Word("pre")) => Ordering::Greater,
// Number wins against Word
(VersionPart::Number(_), VersionPart::Word(_)) => Ordering::Greater,
(VersionPart::Word(_), VersionPart::Number(_)) => Ordering::Less,
(VersionPart::Word(w1), VersionPart::Word(w2)) => w1.cmp(w2),
}
}
}
/// Type used to hold information about a VersionPart during creation
enum InternalPart {
Number { range: RangeInclusive<usize> },
Word { range: RangeInclusive<usize> },
Break,
}
/// An iterator which yields the parts of a version string.
///
/// This can then be directly used to compare two versions
pub struct VersionPartsIter<'a> {
cached_part: InternalPart,
iter: std::str::CharIndices<'a>,
version: &'a str,
}
impl<'a> VersionPartsIter<'a> {
pub fn new(version: &'a str) -> Self {
Self {
cached_part: InternalPart::Break,
iter: version.char_indices(),
version,
}
}
}
impl<'a> Iterator for VersionPartsIter<'a> {
type Item = VersionPart<'a>;
fn next(&mut self) -> Option<Self::Item> {
let char = self.iter.next();
if char.is_none() {
let cached_part = std::mem::replace(&mut self.cached_part, InternalPart::Break);
match cached_part {
InternalPart::Break => return None,
InternalPart::Number { range } => {
return Some(VersionPart::Number(&self.version[range]))
}
InternalPart::Word { range } => {
return Some(VersionPart::Word(&self.version[range]))
}
}
}
let (pos, char) = char.unwrap();
match char {
// Divider encountered
'.' | '-' => {
let cached_part = std::mem::replace(&mut self.cached_part, InternalPart::Break);
match cached_part {
InternalPart::Number { range } => {
Some(VersionPart::Number(&self.version[range]))
}
InternalPart::Word { range } => Some(VersionPart::Word(&self.version[range])),
InternalPart::Break => self.next(),
}
}
// digit encountered
_ if char.is_ascii_digit() => {
let cached_part = std::mem::replace(
&mut self.cached_part,
InternalPart::Number { range: pos..=pos },
);
match cached_part {
InternalPart::Number { range } => {
self.cached_part = InternalPart::Number {
range: *range.start()..=*range.end() + 1,
};
self.next()
}
InternalPart::Word { range } => Some(VersionPart::Word(&self.version[range])),
InternalPart::Break => self.next(),
}
}
// char encountered
_ => {
let mut cached_part = InternalPart::Word { range: pos..=pos };
std::mem::swap(&mut cached_part, &mut self.cached_part);
match cached_part {
InternalPart::Word { range } => {
self.cached_part = InternalPart::Word {
range: *range.start()..=*range.end() + char.len_utf8(),
};
self.next()
}
InternalPart::Number { range } => {
Some(VersionPart::Number(&self.version[range]))
}
InternalPart::Break => self.next(),
}
}
}
}
}
|
