Something went wrong. Try again.
Forked monorepo for Tangled forked from tangled.org/core
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304//! Low-level operations on individual commits.use crate::{ File, Position, bloom::BloomKey, file::{self, CORRECTED_COMMIT_DATE_OFFSET_OVERFLOW, EXTENDED_EDGES_MASK, LAST_EXTENDED_EDGE_MASK, NO_PARENT}, from_be_u32,};use bstr::BStr;use gix_error::{Message, message};use std::{ fmt::{Debug, Formatter}, slice::Chunks,};
/// A commit as stored in a [`File`].#[derive(Copy, Clone)]pub struct Commit<'a> { pub(crate) file: &'a File, pos: file::Position, // We can parse the below fields lazily if needed. commit_timestamp: u64, generation: u32, parent1: ParentEdge, parent2: ParentEdge, root_tree_id: &'a gix_hash::oid,}
impl<'a> Commit<'a> { pub(crate) fn new(file: &'a File, pos: file::Position) -> Self { let bytes = file.commit_data_bytes(pos); Commit { file, pos, root_tree_id: gix_hash::oid::from_bytes_unchecked(&bytes[..file.hash_len]), parent1: ParentEdge::from_raw(from_be_u32(&bytes[file.hash_len..][..4])), parent2: ParentEdge::from_raw(from_be_u32(&bytes[file.hash_len + 4..][..4])), generation: from_be_u32(&bytes[file.hash_len + 8..][..4]) >> 2, commit_timestamp: u64::from_be_bytes(bytes[file.hash_len + 8..][..8].try_into().unwrap()) & 0x0003_ffff_ffff, } }
/// Returns the committer timestamp of this commit. /// /// The value is the number of seconds since 1970-01-01 00:00:00 UTC. pub fn committer_timestamp(&self) -> u64 { self.commit_timestamp }
/// Returns the generation number of this commit. /// /// Commits without parents have generation number 1. Commits with parents have a generation /// number that is the max of their parents' generation numbers + 1. pub fn generation(&self) -> u32 { self.generation }
/// Returns the corrected commit date of this commit (generation number v2), or `None` if the /// owning graph has no generation data. /// /// It is the larger of this commit's committer timestamp and its parents' corrected commit dates plus one. pub fn corrected_commit_date(&self) -> Result<Option<u64>, Message> { let file = self.file; let Some(start) = file.generation_data_offset.filter(|_| file.read_generation_data) else { return Ok(None); }; let offset = from_be_u32(&file.data[start + self.pos.0 as usize * 4..][..4]); let offset = if offset & CORRECTED_COMMIT_DATE_OFFSET_OVERFLOW == 0 { u64::from(offset) } else { let range = file.generation_data_overflow_range.clone().ok_or_else(|| { message!( "Commit {} requires overflow generation data, but there is none", self.id() ) })?; let index = (offset ^ CORRECTED_COMMIT_DATE_OFFSET_OVERFLOW) as usize; let bytes = file.data[range] .get(index * 8..) .and_then(|bytes| bytes.get(..8)) .ok_or_else(|| { message!( "Commit {} has overflow generation data index {index} out of range", self.id() ) })?; u64::from_be_bytes(bytes.try_into().expect("8 bytes")) }; self.commit_timestamp .checked_add(offset) .map(Some) .ok_or_else(|| message!("Commit {} has a corrected commit date that overflows", self.id())) }
/// Returns an iterator over the parent positions for lookup in the owning [Graph][crate::Graph]. pub fn iter_parents(self) -> Parents<'a> { // I didn't find a combinator approach that a) was as strict as ParentIterator, b) supported // fuse-after-first-error behavior, and b) was significantly shorter or more understandable // than ParentIterator. So here we are. Parents { commit_data: self, state: ParentIteratorState::First, } }
/// Returns the hash of this commit. pub fn id(&self) -> &'a gix_hash::oid { self.file.id_at(self.pos) }
/// Returns the first parent of this commit. pub fn parent1(&self) -> Result<Option<Position>, Message> { self.iter_parents().next().transpose() }
/// Returns the position at which this commit is stored in the parent [File]. pub fn position(&self) -> file::Position { self.pos }
/// Return the hash of the tree this commit points to. pub fn root_tree_id(&self) -> &gix_hash::oid { self.root_tree_id }
/// Return the raw bytes of this commit's changed-path Bloom filter, see [`File::bloom_filter_at()`]. pub fn bloom_filter(&self) -> Option<&'a [u8]> { self.file.bloom_filter_at(self.pos) }
/// Query if `path` may be present in this commit's changed-path Bloom filter. pub fn maybe_contains_path(&self, path: &BStr) -> Option<bool> { self.file.maybe_contains_path(self.pos, path) }
/// Query if all `keys` may be present in this commit's changed-path Bloom filter. pub fn maybe_contains_all_keys(&self, keys: &[BloomKey]) -> Option<bool> { self.file.maybe_contains_all_keys(self.pos, keys) }}
impl Debug for Commit<'_> { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { write!( f, "Commit {{ id: {}, lex_pos: {}, generation: {}, root_tree_id: {}, parent1: {:?}, parent2: {:?} }}", self.id(), self.pos, self.generation(), self.root_tree_id(), self.parent1, self.parent2, ) }}
impl Eq for Commit<'_> {}
impl PartialEq for Commit<'_> { fn eq(&self, other: &Self) -> bool { std::ptr::eq(self.file, other.file) && self.pos == other.pos }}
/// An iterator over parents of a [`Commit`].pub struct Parents<'a> { commit_data: Commit<'a>, state: ParentIteratorState<'a>,}
impl Iterator for Parents<'_> { type Item = Result<Position, Message>;
fn next(&mut self) -> Option<Self::Item> { let state = std::mem::replace(&mut self.state, ParentIteratorState::Exhausted); match state { ParentIteratorState::First => match self.commit_data.parent1 { ParentEdge::None => match self.commit_data.parent2 { ParentEdge::None => None, _ => Some(Err(message!( "commit {} has a second parent but not a first parent", self.commit_data.id() ))), }, ParentEdge::GraphPosition(pos) => { self.state = ParentIteratorState::Second; Some(Ok(pos)) } ParentEdge::ExtraEdgeIndex(_) => Some(Err(message!( "commit {}'s first parent is an extra edge index, which is invalid", self.commit_data.id(), ))), }, ParentIteratorState::Second => match self.commit_data.parent2 { ParentEdge::None => None, ParentEdge::GraphPosition(pos) => Some(Ok(pos)), ParentEdge::ExtraEdgeIndex(extra_edge_index) => { if let Some(extra_edges_list) = self.commit_data.file.extra_edges_data() { let start_offset: usize = extra_edge_index .try_into() .expect("an architecture able to hold 32 bits of integer"); let start_offset = start_offset .checked_mul(4) .expect("an extended edge index small enough to fit in usize"); if let Some(tail) = extra_edges_list.get(start_offset..) { self.state = ParentIteratorState::Extra(tail.chunks(4)); // This recursive call is what blocks me from replacing ParentIterator // with a std::iter::from_fn closure. self.next() } else { Some(Err(message!( "commit {}'s extra edges overflows the commit-graph file's extra edges list", self.commit_data.id() ))) } } else { Some(Err(message!( "commit {} has extra edges, but commit-graph file has no extra edges list", self.commit_data.id() ))) } } }, ParentIteratorState::Extra(mut chunks) => { if let Some(chunk) = chunks.next() { let extra_edge = from_be_u32(chunk); match ExtraEdge::from_raw(extra_edge) { ExtraEdge::Internal(pos) => { self.state = ParentIteratorState::Extra(chunks); Some(Ok(pos)) } ExtraEdge::Last(pos) => Some(Ok(pos)), } } else { Some(Err(message!( "commit {}'s extra edges overflows the commit-graph file's extra edges list", self.commit_data.id() ))) } } ParentIteratorState::Exhausted => None, } }
fn size_hint(&self) -> (usize, Option<usize>) { match (&self.state, self.commit_data.parent1, self.commit_data.parent2) { (ParentIteratorState::First, ParentEdge::None, ParentEdge::None) => (0, Some(0)), (ParentIteratorState::First, ParentEdge::None, _) => (1, Some(1)), (ParentIteratorState::First, ParentEdge::GraphPosition(_), ParentEdge::None) => (1, Some(1)), (ParentIteratorState::First, ParentEdge::GraphPosition(_), ParentEdge::GraphPosition(_)) => (2, Some(2)), (ParentIteratorState::First, ParentEdge::GraphPosition(_), ParentEdge::ExtraEdgeIndex(_)) => (3, None), (ParentIteratorState::First, ParentEdge::ExtraEdgeIndex(_), _) => (1, Some(1)), (ParentIteratorState::Second, _, ParentEdge::None) => (0, Some(0)), (ParentIteratorState::Second, _, ParentEdge::GraphPosition(_)) => (1, Some(1)), (ParentIteratorState::Second, _, ParentEdge::ExtraEdgeIndex(_)) => (2, None), (ParentIteratorState::Extra(_), _, _) => (1, None), (ParentIteratorState::Exhausted, _, _) => (0, Some(0)), } }}
#[derive(Debug)]enum ParentIteratorState<'a> { First, Second, Extra(Chunks<'a, u8>), Exhausted,}
#[derive(Clone, Copy, Debug)]enum ParentEdge { None, GraphPosition(Position), ExtraEdgeIndex(u32),}
impl ParentEdge { pub fn from_raw(raw: u32) -> ParentEdge { if raw == NO_PARENT { return ParentEdge::None; } if raw & EXTENDED_EDGES_MASK != 0 { ParentEdge::ExtraEdgeIndex(raw & !EXTENDED_EDGES_MASK) } else { ParentEdge::GraphPosition(Position(raw)) } }}
enum ExtraEdge { Internal(Position), Last(Position),}
impl ExtraEdge { pub fn from_raw(raw: u32) -> Self { if raw & LAST_EXTENDED_EDGE_MASK != 0 { Self::Last(Position(raw & !LAST_EXTENDED_EDGE_MASK)) } else { Self::Internal(Position(raw)) } }}