f760b11 dag: Accept multiple roots in `fold`, remove depth — heartwood

Radicle Heartwood Protocol & Stack

dag: Accept multiple roots in `fold`, remove depth

cloudhead committed 2 years ago

commit f760b1153feb8b9e96493f5ac8dc1efdd7ba580d
parent 5c256c8bfba6e205e687bdd9a0289679f436da3e

3 files changed +10 -56

modified radicle-cob/src/change_graph.rs

@@ -91,7 +91,7 @@ impl ChangeGraph {

         let manifest = root_node.manifest.clone();
         let graph = self
             .graph
             .fold(&root, Dag::new(), |mut graph, _, change, _| {
             .fold(&[root], Dag::new(), |mut graph, _, change| {
                 // Check the change signatures are valid.
                 if !change.valid_signatures() {
                     return ControlFlow::Break(graph);

modified radicle-cob/src/history.rs

@@ -65,7 +65,7 @@ impl History {

         F: for<'r> FnMut(A, &'r EntryId, &'r Entry) -> ControlFlow<A, A>,
     {
         self.graph
             .fold(&self.root, init, |acc, k, v, _| f(acc, k, v))
             .fold(&[self.root], init, |acc, k, v| f(acc, k, v))
     }
     /// Return a topologically-sorted list of history entries.

modified radicle-dag/src/lib.rs

@@ -187,21 +187,21 @@ impl<K: Ord + Copy, V> Dag<K, V> {

     ///
     /// To continue traversing a branch, return [`ControlFlow::Continue`] from the
     /// filter function. To stop traversal of a branch, return [`ControlFlow::Break`].
     pub fn fold<A, F>(&self, root: &K, mut acc: A, mut filter: F) -> A
     pub fn fold<A, F>(&self, roots: &[K], mut acc: A, mut filter: F) -> A
     where
         F: for<'r> FnMut(A, &'r K, &'r Node<K, V>, usize) -> ControlFlow<A, A>,
         F: for<'r> FnMut(A, &'r K, &'r Node<K, V>) -> ControlFlow<A, A>,
     {
         let mut visited = BTreeSet::new();
         let mut queue = VecDeque::<(K, usize)>::from([(*root, 0)]);
         let mut queue = VecDeque::<K>::from_iter(roots.iter().cloned());
         while let Some((next, depth)) = queue.pop_front() {
         while let Some(next) = queue.pop_front() {
             if !visited.insert(next) {
                 continue;
             }
             if let Some(node) = self.graph.get(&next) {
                 match filter(acc, &next, node, depth) {
                 match filter(acc, &next, node) {
                     ControlFlow::Continue(a) => {
                         queue.extend(node.dependents.iter().map(|k| (*k, depth + 1)));
                         queue.extend(node.dependents.iter().cloned());
                         acc = a;
                     }
                     ControlFlow::Break(a) => {

@@ -497,7 +497,7 @@ mod tests {

         dag.dependency("C1", "B2");
         dag.dependency("C1", "B3");
         let acc = dag.fold(&"R", Vec::new(), |mut acc, key, _, _| {
         let acc = dag.fold(&["R"], Vec::new(), |mut acc, key, _| {
             acc.push(*key);
             ControlFlow::Continue(acc)
         });

@@ -505,52 +505,6 @@ mod tests {

     }
     #[test]
     fn test_fold_depth() {
         let mut dag = Dag::new();
         dag.node("R", ());
         dag.node("A1", ());
         dag.node("A2", ());
         dag.node("A3", ());
         dag.node("B1", ());
         dag.node("B2", ());
         dag.node("B3", ());
         dag.node("C1", ());
         dag.dependency("A1", "R");
         dag.dependency("A2", "R");
         dag.dependency("A3", "R");
         dag.dependency("B1", "A1");
         dag.dependency("B2", "A1");
         dag.dependency("B3", "A2");
         dag.dependency("B3", "A3");
         dag.dependency("C1", "B1");
         dag.dependency("C1", "B2");
         dag.dependency("C1", "B3");
         let acc = dag.fold(&"R", Vec::new(), |mut acc, key, _, depth| {
             acc.push((*key, depth));
             ControlFlow::Continue(acc)
         });
         assert_eq!(
             acc,
             vec![
                 ("R", 0),
                 ("A1", 1),
                 ("A2", 1),
                 ("A3", 1),
                 ("B1", 2),
                 ("B2", 2),
                 ("B3", 2),
                 ("C1", 3)
             ]
         );
     }
     #[test]
     fn test_fold_reject() {
         let mut dag = Dag::new();

@@ -571,7 +525,7 @@ mod tests {

         let a1 = dag.get(&"A1").unwrap();
         assert_eq!(dag.descendants_of(a1), vec!["B1", "C1", "D1"]);
         let acc = dag.fold(&"R", Vec::new(), |mut acc, key, accept, _| {
         let acc = dag.fold(&["R"], Vec::new(), |mut acc, key, accept| {
             if !accept.value {
                 ControlFlow::Break(acc)
             } else {