This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9105

hg-core: renaming of `Chunk` offset methods (D8958#inline-15002 followup)
ClosedPublic

Authored by acezar on Sep 28 2020, 9:48 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGb68b19104d16: hg-core: renaming of `Chunk` offset methods (D8958#inline-15002 followup)

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Revision Contents
Changeset List

PathPackages
Mrust/hg-core/src/revlog/patch.rs (18 lines)

Diff 22918

rust/hg-core/src/revlog/patch.rs

data: &'a [u8], data: &'a [u8],
} }
impl Chunk<'_> { impl Chunk<'_> {
/// Adjusted start of the chunk to replace. /// Adjusted start of the chunk to replace.
/// ///
/// The offset, taking into account the growth/shrinkage of data /// The offset, taking into account the growth/shrinkage of data
/// induced by previously applied chunks. /// induced by previously applied chunks.
fn start_offseted_by(&self, offset: i32) -> u32 { fn start_offset_by(&self, offset: i32) -> u32 {
let start = self.start as i32 + offset; let start = self.start as i32 + offset;
assert!(start >= 0, "negative chunk start should never happen"); assert!(start >= 0, "negative chunk start should never happen");
start as u32 start as u32
} }
/// Adjusted end of the chunk to replace. /// Adjusted end of the chunk to replace.
/// ///
/// The offset, taking into account the growth/shrinkage of data /// The offset, taking into account the growth/shrinkage of data
/// induced by previously applied chunks. /// induced by previously applied chunks.
fn end_offseted_by(&self, offset: i32) -> u32 { fn end_offset_by(&self, offset: i32) -> u32 {
self.start_offseted_by(offset) + self.data.len() as u32 self.start_offset_by(offset) + self.data.len() as u32
} }
/// Length of the replaced chunk. /// Length of the replaced chunk.
fn replaced_len(&self) -> u32 { fn replaced_len(&self) -> u32 {
self.end - self.start self.end - self.start
} }
/// Length difference between the replacing data and the replaced data. /// Length difference between the replacing data and the replaced data.
let mut pos = 0; let mut pos = 0;
// For each chunk of `other`, chunks of `self` are processed // For each chunk of `other`, chunks of `self` are processed
// until they start after the end of the current chunk. // until they start after the end of the current chunk.
for Chunk { start, end, data } in other.chunks.iter() { for Chunk { start, end, data } in other.chunks.iter() {
// Add chunks of `self` that start before this chunk of `other` // Add chunks of `self` that start before this chunk of `other`
// without overlap. // without overlap.
while pos < self.chunks.len() while pos < self.chunks.len()
&& self.chunks[pos].end_offseted_by(offset) <= *start && self.chunks[pos].end_offset_by(offset) <= *start
{ {
let first = self.chunks[pos].clone(); let first = self.chunks[pos].clone();
offset += first.len_diff(); offset += first.len_diff();
chunks.push(first); chunks.push(first);
pos += 1; pos += 1;
} }
// The current chunk of `self` starts before this chunk of `other` // The current chunk of `self` starts before this chunk of `other`
// with overlap. // with overlap.
// The left-most part of data is added as an insertion chunk. // The left-most part of data is added as an insertion chunk.
// The right-most part data is kept in the chunk. // The right-most part data is kept in the chunk.
if pos < self.chunks.len() if pos < self.chunks.len()
&& self.chunks[pos].start_offseted_by(offset) < *start && self.chunks[pos].start_offset_by(offset) < *start
{ {
let first = &mut self.chunks[pos]; let first = &mut self.chunks[pos];
let (data_left, data_right) = first.data.split_at( let (data_left, data_right) = first.data.split_at(
(*start - first.start_offseted_by(offset)) as usize, (*start - first.start_offset_by(offset)) as usize,
); );
let left = Chunk { let left = Chunk {
start: first.start, start: first.start,
end: first.start, end: first.start,
data: data_left, data: data_left,
}; };
first.data = data_right; first.data = data_right;
// chunk of `other`. // chunk of `other`.
// Offset tracking continues with `end_offset` to adjust the end // Offset tracking continues with `end_offset` to adjust the end
// of the current chunk of `other`. // of the current chunk of `other`.
let mut next_offset = offset; let mut next_offset = offset;
// Discard the chunks of `self` that are totally overridden // Discard the chunks of `self` that are totally overridden
// by the current chunk of `other` // by the current chunk of `other`
while pos < self.chunks.len() while pos < self.chunks.len()
&& self.chunks[pos].end_offseted_by(next_offset) <= *end && self.chunks[pos].end_offset_by(next_offset) <= *end
{ {
let first = &self.chunks[pos]; let first = &self.chunks[pos];
next_offset += first.len_diff(); next_offset += first.len_diff();
pos += 1; pos += 1;
} }
// Truncate the left-most part of chunk of `self` that overlaps // Truncate the left-most part of chunk of `self` that overlaps
// the current chunk of `other`. // the current chunk of `other`.
if pos < self.chunks.len() if pos < self.chunks.len()
&& self.chunks[pos].start_offseted_by(next_offset) < *end && self.chunks[pos].start_offset_by(next_offset) < *end
{ {
let first = &mut self.chunks[pos]; let first = &mut self.chunks[pos];
let how_much_to_discard = let how_much_to_discard =
*end - first.start_offseted_by(next_offset); *end - first.start_offset_by(next_offset);
first.data = &first.data[(how_much_to_discard as usize)..]; first.data = &first.data[(how_much_to_discard as usize)..];
next_offset += how_much_to_discard as i32; next_offset += how_much_to_discard as i32;
} }
// Add the chunk of `other` with adjusted position. // Add the chunk of `other` with adjusted position.
chunks.push(Chunk { chunks.push(Chunk {