barrett/likewise
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 3

Some more saner variable names

Browse source
This commit is contained in:
Armin Ronacher 2021-01-17 23:10:01 +01:00
parent af43d14243
commit e556888ce5
2 changed files with 70 additions and 54 deletions
Download patch file Download diff file Expand all files Collapse all files

54
src/algorithms/myers.rs
View file

@ -55,11 +55,11 @@ where
pub(crate) fn diff_offsets<D, Old, New>(
diff: &mut D,
old: &Old,
i: usize,
i_: usize,
old_current: usize,
old_end: usize,
new: &New,
j: usize,
j_: usize,
new_current: usize,
new_end: usize,
) -> Result<(), D::Error>
where
D: DiffHook + ?Sized,
@ -67,9 +67,9 @@ where
New: Index<usize> + ?Sized,
New::Output: PartialEq<Old::Output>,
{
if i_ > i && j_ > j {
let n = i_ - i;
let m = j_ - j;
if old_end > old_current && new_end > new_current {
let n = old_end - old_current;
let m = new_end - new_current;
let l = (n + m) as isize;
let z = (2 * min(n, m) + 2) as usize;
let w = n as isize - m as isize;
@ -102,7 +102,7 @@ where
} else {
(n - a - 1, m - b - 1)
};
new[j + f_i] == old[i + e_i]
new[new_current + f_i] == old[old_current + e_i]
} {
a += 1;
b += 1;
@ -120,19 +120,35 @@ where
(n - a, m - b, n - s, m - t)
};
if h + bound > 1 || (x != u && y != v) {
diff_offsets(diff, old, i, i + x, new, j, j + y)?;
diff_offsets(
diff,
old,
old_current,
old_current + x,
new,
new_current,
new_current + y,
)?;
if x != u {
diff.equal(i + x, j + y, u - x)?;
diff.equal(old_current + x, new_current + y, u - x)?;
}
diff_offsets(diff, old, i + u, i_, new, j + v, j_)?;
diff_offsets(
diff,
old,
old_current + u,
old_end,
new,
new_current + v,
new_end,
)?;
return Ok(());
} else if m > n {
diff.equal(i, j, n)?;
diff.insert(i + n, j + n, m - n)?;
diff.equal(old_current, new_current, n)?;
diff.insert(old_current + n, new_current + n, m - n)?;
return Ok(());
} else if m < n {
diff.equal(i, j, m)?;
diff.delete(i + m, n - m, j + m)?;
diff.equal(old_current, new_current, m)?;
diff.delete(old_current + m, n - m, new_current + m)?;
return Ok(());
} else {
return Ok(());
@ -141,10 +157,10 @@ where
}
}
}
} else if i_ > i {
diff.delete(i, i_ - i, j)?
} else if j_ > j {
diff.insert(i, j, j_ - j)?
} else if old_end > old_current {
diff.delete(old_current, old_end - old_current, new_current)?
} else if new_end > new_current {
diff.insert(old_current, new_current, new_end - new_current)?
}
Ok(())
}

70
src/algorithms/patience.rs
View file

@ -68,13 +68,13 @@ where
struct Patience<'old, 'new, 'd, Old: ?Sized, New: ?Sized, D> {
d: &'d mut D,
old: &'old Old,
old_current: usize,
old_end: usize,
old_indexes: &'old [Indexable<'old, Old>],
new: &'new New,
current_old: usize,
end_old: usize,
current_new: usize,
end_new: usize,
indexes_old: &'old [Indexable<'old, Old>],
indexes_new: &'new [Indexable<'new, New>],
new_current: usize,
new_end: usize,
new_indexes: &'new [Indexable<'new, New>],
}
impl<'old, 'new, 'd, Old, New, D> DiffHook for Patience<'old, 'new, 'd, Old, New, D>
@ -87,29 +87,29 @@ where
type Error = D::Error;
fn equal(&mut self, old: usize, new: usize, len: usize) -> Result<(), D::Error> {
for (old, new) in (old..old + len).zip(new..new + len) {
let a0 = self.current_old;
let b0 = self.current_new;
while self.current_old < self.indexes_old[old].index
&& self.current_new < self.indexes_new[new].index
&& self.new[self.current_new] == self.old[self.current_old]
let a0 = self.old_current;
let b0 = self.new_current;
while self.old_current < self.old_indexes[old].index
&& self.new_current < self.new_indexes[new].index
&& self.new[self.new_current] == self.old[self.old_current]
{
self.current_old += 1;
self.current_new += 1;
self.old_current += 1;
self.new_current += 1;
}
if self.current_old > a0 {
self.d.equal(a0, b0, self.current_old - a0)?
if self.old_current > a0 {
self.d.equal(a0, b0, self.old_current - a0)?
}
myers::diff_offsets(
self.d,
self.old,
self.current_old,
self.indexes_old[old].index,
self.old_current,
self.old_indexes[old].index,
self.new,
self.current_new,
self.indexes_new[new].index,
self.new_current,
self.new_indexes[new].index,
)?;
self.current_old = self.indexes_old[old].index;
self.current_new = self.indexes_new[new].index;
self.old_current = self.old_indexes[old].index;
self.new_current = self.new_indexes[new].index;
}
Ok(())
}
@ -118,9 +118,9 @@ where
myers::diff(
self.d,
self.old,
self.current_old..self.end_old,
self.old_current..self.old_end,
self.new,
self.current_new..self.end_new,
self.new_current..self.new_end,
)
}
}
@ -142,26 +142,26 @@ where
New::Output: PartialEq<Old::Output> + Hash + Eq,
D: DiffHook,
{
let indexes_old = unique(old, old_range.start, old_range.end);
let indexes_new = unique(new, old_range.start, old_range.end);
let old_indexes = unique(old, old_range.start, old_range.end);
let new_indexes = unique(new, old_range.start, old_range.end);
let mut d = Replace::new(Patience {
d,
old,
old_current: old_range.start,
old_end: old_range.end,
old_indexes: &old_indexes,
new,
current_old: old_range.start,
end_old: old_range.end,
current_new: new_range.start,
end_new: new_range.end,
indexes_old: &indexes_old,
indexes_new: &indexes_new,
new_current: new_range.start,
new_end: new_range.end,
new_indexes: &new_indexes,
});
myers::diff(
&mut d,
&indexes_old,
0..indexes_old.len(),
&indexes_new,
0..indexes_new.len(),
&old_indexes,
0..old_indexes.len(),
&new_indexes,
0..new_indexes.len(),
)?;
Ok(())
}