use crate::tree::visit::Visit;use git_hash::{oid, ObjectId};use git_object::{immutable, tree};use quick_error::quick_error;use std::{borrow::BorrowMut, collections::VecDeque};quick_error! { /// The error is part of the item returned by the [`traverse()`] function. #[derive(Debug)] #[allow(missing_docs)] pub enum Error { NotFound{oid: ObjectId} { display("The object {} could not be found", oid) } Cancelled { display("The delegate cancelled the operation") } ObjectDecode(err: immutable::object::decode::Error) { display("An object could not be decoded") source(err) from() } }}/// The state used and potentially shared by multiple tree traversals.#[derive(Default, Clone)]pub struct State<PathId: Clone> { next: VecDeque<(Option<PathId>, ObjectId)>, buf: Vec<u8>,}impl<PathId: Clone> State<PathId> { fn clear(&mut self) { self.next.clear(); self.buf.clear(); }}/// Start a breadth-first iteration over the `root` trees entries.////// * `root`/// * the starting points of the iteration/// * each commit they lead to will only be returned once, including the tip that started it/// * `state` - all state used for the iteration. If multiple iterations are performed, allocations can be minimized by reusing/// this state./// * `find` - a way to lookup new object data during traversal by their ObjectId, writing their data into buffer and returning/// an iterator over entries if the object is present and is a tree. Caching should be implemented within this function/// as needed. The return value is `Option<TreeIter>` which degenerates all error information. Not finding a commit should also/// be considered an errors as all objects in the tree DAG should be present in the database. Hence [`Error::NotFound`] should/// be escalated into a more specific error if its encountered by the caller./// * `delegate` - A way to observe entries and control the iteration while allowing the optimizer to let you pay only for what you use.pub fn traverse<StateMut, Find, V>( root: impl Into<ObjectId>, mut state: StateMut, mut find: Find, delegate: &mut V,) -> Result<(), Error>where Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Option<immutable::TreeIter<'a>>, StateMut: BorrowMut<State<V::PathId>>, V: Visit,{ let state = state.borrow_mut(); state.clear(); state.next.push_back((None, root.into())); while let Some((path_id, oid)) = state.next.pop_front() { if let Some(path_id) = path_id { delegate.set_current_path(path_id); } match find(&oid, &mut state.buf) { Some(tree_iter) => { for entry in tree_iter { let entry = entry?; match entry.mode { tree::EntryMode::Tree => { use super::visit::Action::*; let path_id = delegate.push_tracked_path_component(entry.filename); let action = delegate.visit_tree(&entry); match action { Skip => {} Continue => state.next.push_back((Some(path_id), entry.oid.to_owned())), Cancel => { return Err(Error::Cancelled); } } } _non_tree => { delegate.push_path_component(entry.filename); if delegate.visit_nontree(&entry).cancelled() { return Err(Error::Cancelled); } } } delegate.pop_path_component(); } } None => return Err(Error::NotFound { oid: oid.to_owned() }), } } Ok(())}
use crate::tree::visit::Visit;
use git_hash::{oid, ObjectId};
use git_object::{immutable, tree};
use quick_error::quick_error;
use std::{borrow::BorrowMut, collections::VecDeque};
quick_error! {
/// The error is part of the item returned by the [`traverse()`] function.
#[derive(Debug)]
#[allow(missing_docs)]
pub enum Error {
NotFound{oid: ObjectId} {
display("The object {} could not be found", oid)
}
Cancelled {
display("The delegate cancelled the operation")
}
ObjectDecode(err: immutable::object::decode::Error) {
display("An object could not be decoded")
source(err)
from()
}
}
}
/// The state used and potentially shared by multiple tree traversals.
#[derive(Default, Clone)]
pub struct State<PathId: Clone> {
next: VecDeque<(Option<PathId>, ObjectId)>,
buf: Vec<u8>,
}
impl<PathId: Clone> State<PathId> {
fn clear(&mut self) {
self.next.clear();
self.buf.clear();
}
}
/// Start a breadth-first iteration over the `root` trees entries.
///
/// * `root`
/// * the starting points of the iteration
/// * each commit they lead to will only be returned once, including the tip that started it
/// * `state` - all state used for the iteration. If multiple iterations are performed, allocations can be minimized by reusing
/// this state.
/// * `find` - a way to lookup new object data during traversal by their ObjectId, writing their data into buffer and returning
/// an iterator over entries if the object is present and is a tree. Caching should be implemented within this function
/// as needed. The return value is `Option<TreeIter>` which degenerates all error information. Not finding a commit should also
/// be considered an errors as all objects in the tree DAG should be present in the database. Hence [`Error::NotFound`] should
/// be escalated into a more specific error if its encountered by the caller.
/// * `delegate` - A way to observe entries and control the iteration while allowing the optimizer to let you pay only for what you use.
pub fn traverse<StateMut, Find, V>(
root: impl Into<ObjectId>,
mut state: StateMut,
mut find: Find,
delegate: &mut V,
) -> Result<(), Error>
where
Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Option<immutable::TreeIter<'a>>,
StateMut: BorrowMut<State<V::PathId>>,
V: Visit,
{
let state = state.borrow_mut();
state.clear();
state.next.push_back((None, root.into()));
while let Some((path_id, oid)) = state.next.pop_front() {
if let Some(path_id) = path_id {
delegate.set_current_path(path_id);
}
match find(&oid, &mut state.buf) {
Some(tree_iter) => {
for entry in tree_iter {
let entry = entry?;
match entry.mode {
tree::EntryMode::Tree => {
use super::visit::Action::*;
let path_id = delegate.push_tracked_path_component(entry.filename);
let action = delegate.visit_tree(&entry);
match action {
Skip => {}
Continue => state.next.push_back((Some(path_id), entry.oid.to_owned())),
Cancel => {
return Err(Error::Cancelled);
}
}
}
_non_tree => {
delegate.push_path_component(entry.filename);
if delegate.visit_nontree(&entry).cancelled() {
return Err(Error::Cancelled);
}
}
}
delegate.pop_path_component();
}
}
None => return Err(Error::NotFound { oid: oid.to_owned() }),
}
}
Ok(())
}