From c6dcd35e0fed7cb9dd1db08c6781f5cff96f5402 Mon Sep 17 00:00:00 2001 From: Adam Fortune Date: Fri, 24 Nov 2023 12:05:02 -0600 Subject: [PATCH] Add .leaves() method to ancestor iterators and run cargo fmt --- Cargo.toml | 2 +- README.md | 106 +- src/bfs_iterators/borrow.rs | 190 +- src/bfs_iterators/mod.rs | 150 +- src/bfs_iterators/mut_borrow.rs | 224 +- src/bfs_iterators/owned.rs | 225 +- src/dfs_inorder_iterators/borrow.rs | 98 +- src/dfs_inorder_iterators/mod.rs | 49 +- src/dfs_inorder_iterators/mut_borrow.rs | 119 +- src/dfs_inorder_iterators/owned.rs | 116 +- src/dfs_postorder_iterators/borrow.rs | 180 +- src/dfs_postorder_iterators/mod.rs | 104 +- src/dfs_postorder_iterators/mut_borrow.rs | 209 +- src/dfs_postorder_iterators/owned.rs | 203 +- src/dfs_preorder_iterators/borrow.rs | 171 +- src/dfs_preorder_iterators/mod.rs | 50 +- src/dfs_preorder_iterators/mut_borrow.rs | 204 +- src/dfs_preorder_iterators/owned.rs | 195 +- src/examples.rs | 178 +- .../ancestors_breadth_first/borrow.rs | 116 + .../ancestors_breadth_first/mod.rs | 233 ++ .../ancestors_breadth_first/mut_borrow.rs | 134 + .../ancestors_breadth_first/owned.rs | 128 + .../ancestors_depth_first/borrow.rs | 65 + .../ancestors_depth_first/mod.rs | 135 + .../ancestors_depth_first/mut_borrow.rs | 83 + .../ancestors_depth_first/owned.rs | 81 + src/leaves_iterators/breadth_first/borrow.rs | 67 +- src/leaves_iterators/breadth_first/mod.rs | 100 +- .../breadth_first/mut_borrow.rs | 80 +- src/leaves_iterators/breadth_first/owned.rs | 91 +- src/leaves_iterators/depth_first/borrow.rs | 74 +- src/leaves_iterators/depth_first/mod.rs | 83 +- .../depth_first/mut_borrow.rs | 76 +- src/leaves_iterators/depth_first/owned.rs | 66 +- src/leaves_iterators/mod.rs | 6 +- src/prelude.rs | 2178 +++++++++++------ 37 files changed, 4293 insertions(+), 2276 deletions(-) create mode 100644 src/leaves_iterators/ancestors_breadth_first/borrow.rs create mode 100644 src/leaves_iterators/ancestors_breadth_first/mod.rs create mode 100644 src/leaves_iterators/ancestors_breadth_first/mut_borrow.rs create mode 100644 src/leaves_iterators/ancestors_breadth_first/owned.rs create mode 100644 src/leaves_iterators/ancestors_depth_first/borrow.rs create mode 100644 src/leaves_iterators/ancestors_depth_first/mod.rs create mode 100644 src/leaves_iterators/ancestors_depth_first/mut_borrow.rs create mode 100644 src/leaves_iterators/ancestors_depth_first/owned.rs diff --git a/Cargo.toml b/Cargo.toml index 04bb9b8..c765d5d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,7 +6,7 @@ description = "tree-iterators-rs is a library built to provide you with the iter license = "MIT" repository = "https://github.com/mr-adult/tree-iterators-rs" documentation = "https://docs.rs/tree_iterators_rs/latest/tree_iterators_rs/" -keywords = ["tree", "dfs", "bfs", "traversal", "depth first", "breadth first", "iterator", "traverse", "search", "graph"] +keywords = ["tree", "dfs", "bfs", "traversal", "depth first", "breadth first", "traverse", "search", "graph", "bft", "dft", "preorder", "postorder", "inorder", "pre order", "post order", "in order"] # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html diff --git a/README.md b/README.md index 516b365..cc13c38 100644 --- a/README.md +++ b/README.md @@ -503,56 +503,6 @@ println!("{}", result); ## Iterator Modifiers -### Leaves - -leaves() is a method that can be called after any of the above APIs to change the iterator structure to one that only returns leaves of the tree. In the example tree (see above documentation), this will always result in the sequence 3, 4, 5, 10. Once this method is called, the iterator transforms to be either a breadth-first (if the iterator was previously breadth-first) or a depth first postorder search (if the iterator was previously one of pre-, in-, or post-order depth first searches). - -I will be using the depth first preorder search in the examples, but this works with all of the traversal types. This method can be called immediately if you wish to only receive the leaves of the tree like so: -```rust -use tree_iterators_rs::{ - examples::create_example_tree, - prelude::* -}; - -let root = create_example_tree(); - -let result = root.dfs_preorder() - .leaves() - .map(|val| val.to_string()) - .collect::>() - .join(", "); - -// result: 3, 4, 5, 10 -println!("{}", result); -``` - -Alternatively, this method can be used to perform a normal traversal and then switch to a leaves-only traversal partway through the regular one. This can be done like so (again, all traversal types support this): -```rust -use tree_iterators_rs::{ - examples::create_example_tree, - prelude::* -}; - -let root = create_example_tree(); - -let mut dfs_preorder = root.dfs_preorder(); - -let mut results = Vec::new(); -// take the first 2 non-leaves before switching to a leaves-only iterator -results.push(dfs_preorder.next().unwrap().to_string()); -results.push(dfs_preorder.next().unwrap().to_string()); - -// once leaves is called, iteration switches to a depth-first postorder search -for leaf in dfs_preorder.leaves() { - results.push(leaf.to_string()); -} - -let result = results.join(", "); - -// result: 0, 1, 3, 4, 5, 10, -println!("{}", result); -``` - ### Attach Ancestors attach_ancestors() is a method that can be called after any of the above APIs to change the iterator structure into one that returns a slice of all ancestors and the current value in the tree. If one of these is called, the (now streaming) iterator will yield a slice where the item at index 0 is the root value, the item at index len() - 1 is the current value, and everything in between is the other ancestors. As an example, when we are at the value of 10 in our traversal (see above documentation), the slice will look like this: \[0, 2, 6, 7, 8, 9, 10\]. @@ -667,6 +617,56 @@ root.bfs_iter() println!("{}", result); ``` +### Leaves + +leaves() is a method that can be called after any of the above APIs (including attach_ancestors()) to change the iterator structure to one that only returns leaves of the tree. In the example tree (see above documentation), this will always result in the sequence 3, 4, 5, 10. Once this method is called, the iterator transforms to be either a breadth-first (if the iterator was previously breadth-first) or a depth first postorder search (if the iterator was previously one of pre-, in-, or post-order depth first searches). + +I will be using the depth first preorder search in the examples, but this works with all of the traversal types. This method can be called immediately if you wish to only receive the leaves of the tree like so: +```rust +use tree_iterators_rs::{ + examples::create_example_tree, + prelude::* +}; + +let root = create_example_tree(); + +let result = root.dfs_preorder() + .leaves() + .map(|val| val.to_string()) + .collect::>() + .join(", "); + +// result: 3, 4, 5, 10 +println!("{}", result); +``` + +Alternatively, this method can be used to perform a normal traversal and then switch to a leaves-only traversal partway through the regular one. This can be done like so (again, all traversal types support this): +```rust +use tree_iterators_rs::{ + examples::create_example_tree, + prelude::* +}; + +let root = create_example_tree(); + +let mut dfs_preorder = root.dfs_preorder(); + +let mut results = Vec::new(); +// take the first 2 non-leaves before switching to a leaves-only iterator +results.push(dfs_preorder.next().unwrap().to_string()); +results.push(dfs_preorder.next().unwrap().to_string()); + +// once leaves is called, iteration switches to a depth-first postorder search +for leaf in dfs_preorder.leaves() { + results.push(leaf.to_string()); +} + +let result = results.join(", "); + +// result: 0, 1, 3, 4, 5, 10, +println!("{}", result); +``` + ## Custom Tree Node Implementations This crates' APIs are powered by 3 traits. The traits include: @@ -697,7 +697,7 @@ We can start with the OwnedTreeNode implementation as follows. Since we chose to ```rust use tree_iterators_rs::prelude::*; use std::collections::{ - LinkedList + LinkedList, linked_list::IntoIter }; @@ -726,7 +726,7 @@ The mutable borrow implementation is very similar to the owned one. The only dif ```rust use tree_iterators_rs::prelude::*; use std::collections::{ - LinkedList + LinkedList, linked_list::IterMut }; @@ -757,7 +757,7 @@ The borrow implementation is also very similar to the owned one. The only differ ```rust use tree_iterators_rs::prelude::*; use std::collections::{ - LinkedList + LinkedList, linked_list::Iter }; diff --git a/src/bfs_iterators/borrow.rs b/src/bfs_iterators/borrow.rs index fe4cb6e..31cdcac 100644 --- a/src/bfs_iterators/borrow.rs +++ b/src/bfs_iterators/borrow.rs @@ -1,55 +1,48 @@ -use alloc::{ - collections::VecDeque, - vec::Vec -}; +use alloc::{collections::VecDeque, vec::Vec}; use streaming_iterator::StreamingIterator; use crate::{ + leaves_iterators::{ + ancestors_breadth_first::borrow::{ + BorrowedBFSLeavesIteratorWithAncestors, BorrowedBinaryBFSLeavesIteratorWithAncestors, + }, + breadth_first::borrow::{BorrowedBinaryLeavesIterator, BorrowedLeavesIterator}, + }, prelude::{ - BorrowedTreeNode, - BinaryChildren, - BorrowedBinaryTreeNode, - TreeIterator, - LeavesIterator, - AncestorsIterator - }, - leaves_iterators::breadth_first::borrow::{ - BorrowedLeavesIterator, - BorrowedBinaryLeavesIterator - } + AncestorsIterator, AncestorsLeavesIterator, BinaryChildren, BorrowedBinaryTreeNode, + BorrowedTreeNode, LeavesIterator, TreeIterator, + }, }; -use super::{ - bfs_next, - bfs_advance_iterator, - bfs_streaming_iterator_impl, - TreeNodeVecDeque, -}; - -pub struct BorrowedBFSIterator<'a, Node> - where Node: BorrowedTreeNode<'a> { +use super::{bfs_advance_iterator, bfs_next, bfs_streaming_iterator_impl, TreeNodeVecDeque}; +pub struct BorrowedBFSIterator<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ root: Option<&'a Node>, - traversal_queue: VecDeque + traversal_queue: VecDeque, } impl<'a, Node> BorrowedBFSIterator<'a, Node> - where Node: BorrowedTreeNode<'a> { - - pub (crate) fn new(root: &'a Node) -> BorrowedBFSIterator<'a, Node> { - BorrowedBFSIterator { - root: Some(root), - traversal_queue: VecDeque::new() +where + Node: BorrowedTreeNode<'a>, +{ + pub(crate) fn new(root: &'a Node) -> BorrowedBFSIterator<'a, Node> { + BorrowedBFSIterator { + root: Some(root), + traversal_queue: VecDeque::new(), } } } -impl<'a, Node> TreeIterator for BorrowedBFSIterator<'a, Node> - where Node: BorrowedTreeNode<'a> { - +impl<'a, Node> TreeIterator for BorrowedBFSIterator<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ fn leaves(self) -> impl LeavesIterator { BorrowedLeavesIterator { - root: self.root, + root: self.root, old_traversal_queue: self.traversal_queue, new_traversal_queue: VecDeque::new(), } @@ -63,26 +56,29 @@ impl<'a, Node> TreeIterator for BorrowedBFSIterator<'a, Node> } } -impl<'a, Node> Iterator for BorrowedBFSIterator<'a, Node> - where Node: BorrowedTreeNode<'a> { - +impl<'a, Node> Iterator for BorrowedBFSIterator<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ type Item = Node::BorrowedValue; bfs_next!(get_value_and_children_iter); } -pub struct BorrowedBFSIteratorWithAncestors<'a, Node> - where Node: BorrowedTreeNode<'a> { - - is_root: bool, - item_stack: Vec, - tree_cache: TreeNodeVecDeque, - traversal_stack: Vec>, - iterator_queue: VecDeque>, +pub struct BorrowedBFSIteratorWithAncestors<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ + pub(crate) is_root: bool, + pub(crate) item_stack: Vec, + pub(crate) tree_cache: TreeNodeVecDeque, + pub(crate) traversal_stack: Vec>, + pub(crate) iterator_queue: VecDeque>, } -impl<'a, Node> BorrowedBFSIteratorWithAncestors<'a, Node> - where Node: BorrowedTreeNode<'a> { - +impl<'a, Node> BorrowedBFSIteratorWithAncestors<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ fn new(root: &'a Node) -> BorrowedBFSIteratorWithAncestors<'a, Node> { let (value, children) = root.get_value_and_children_iter(); let tree_cache = TreeNodeVecDeque { @@ -108,47 +104,58 @@ impl<'a, Node> BorrowedBFSIteratorWithAncestors<'a, Node> } impl<'a, Node> AncestorsIterator for BorrowedBFSIteratorWithAncestors<'a, Node> - where Node: BorrowedTreeNode<'a> {} - -impl<'a, Node> StreamingIterator for BorrowedBFSIteratorWithAncestors<'a, Node> - where Node: BorrowedTreeNode<'a> { +where + Node: BorrowedTreeNode<'a>, +{ + fn leaves(self) -> impl AncestorsLeavesIterator { + BorrowedBFSLeavesIteratorWithAncestors::new(self) + } +} +impl<'a, Node> StreamingIterator for BorrowedBFSIteratorWithAncestors<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ type Item = [Node::BorrowedValue]; bfs_streaming_iterator_impl!(get_value_and_children_iter); } -pub struct BorrowedBinaryBFSIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +pub struct BorrowedBinaryBFSIterator<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ root: Option<&'a Node>, - traversal_queue: VecDeque> + traversal_queue: VecDeque>, } impl<'a, Node> BorrowedBinaryBFSIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - - pub (crate) fn new(root: &'a Node) -> BorrowedBinaryBFSIterator<'a, Node> { - BorrowedBinaryBFSIterator { - root: Some(root), - traversal_queue: VecDeque::new() +where + Node: BorrowedBinaryTreeNode<'a>, +{ + pub(crate) fn new(root: &'a Node) -> BorrowedBinaryBFSIterator<'a, Node> { + BorrowedBinaryBFSIterator { + root: Some(root), + traversal_queue: VecDeque::new(), } } } -impl<'a, Node> Iterator for BorrowedBinaryBFSIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +impl<'a, Node> Iterator for BorrowedBinaryBFSIterator<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ type Item = Node::BorrowedValue; bfs_next!(get_value_and_children_iter); } -impl<'a, Node> TreeIterator for BorrowedBinaryBFSIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +impl<'a, Node> TreeIterator for BorrowedBinaryBFSIterator<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ fn leaves(self) -> impl LeavesIterator { - BorrowedBinaryLeavesIterator { - root: self.root, + BorrowedBinaryLeavesIterator { + root: self.root, old_traversal_queue: self.traversal_queue, new_traversal_queue: VecDeque::new(), } @@ -162,19 +169,21 @@ impl<'a, Node> TreeIterator for BorrowedBinaryBFSIterator<'a, Node> } } -pub struct BorrowedBinaryBFSIteratorWithAncestors<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - - is_root: bool, - item_stack: Vec, - tree_cache: TreeNodeVecDeque, - traversal_stack: Vec>, - iterator_queue: VecDeque>>, +pub struct BorrowedBinaryBFSIteratorWithAncestors<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ + pub(crate) is_root: bool, + pub(crate) item_stack: Vec, + pub(crate) tree_cache: TreeNodeVecDeque, + pub(crate) traversal_stack: Vec>, + pub(crate) iterator_queue: VecDeque>>, } -impl<'a, Node> BorrowedBinaryBFSIteratorWithAncestors<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +impl<'a, Node> BorrowedBinaryBFSIteratorWithAncestors<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ fn new(root: &'a Node) -> BorrowedBinaryBFSIteratorWithAncestors<'a, Node> { let (value, children) = root.get_value_and_children_iter(); let tree_cache = TreeNodeVecDeque { @@ -199,13 +208,20 @@ impl<'a, Node> BorrowedBinaryBFSIteratorWithAncestors<'a, Node> bfs_advance_iterator!(get_value_and_children_iter); } -impl<'a, Node> StreamingIterator for BorrowedBinaryBFSIteratorWithAncestors<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +impl<'a, Node> StreamingIterator for BorrowedBinaryBFSIteratorWithAncestors<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ type Item = [Node::BorrowedValue]; bfs_streaming_iterator_impl!(get_value_and_children_iter); } -impl<'a, Node> AncestorsIterator for BorrowedBinaryBFSIteratorWithAncestors<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> {} \ No newline at end of file +impl<'a, Node> AncestorsIterator for BorrowedBinaryBFSIteratorWithAncestors<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ + fn leaves(self) -> impl AncestorsLeavesIterator { + BorrowedBinaryBFSLeavesIteratorWithAncestors::new(self) + } +} diff --git a/src/bfs_iterators/mod.rs b/src/bfs_iterators/mod.rs index 732ef0e..3cffcd8 100644 --- a/src/bfs_iterators/mod.rs +++ b/src/bfs_iterators/mod.rs @@ -1,6 +1,6 @@ -pub mod owned; -pub mod mut_borrow; pub mod borrow; +pub mod mut_borrow; +pub mod owned; macro_rules! bfs_next { ($get_value_and_children: ident) => { @@ -16,29 +16,26 @@ macro_rules! bfs_next { } return Some(value); } - None => { - loop { - let next_queue_opt = self.traversal_queue.get_mut(0); - match next_queue_opt { - None => return None, - Some(next_queue) => { - match next_queue.next() { - None => { - self.traversal_queue.pop_front(); - continue; - } - Some(next) => { - let (value, children) = next.$get_value_and_children(); - match children { - None => {} - Some(children) => self.traversal_queue.push_back(children) } - return Some(value); - } + None => loop { + let next_queue_opt = self.traversal_queue.get_mut(0); + match next_queue_opt { + None => return None, + Some(next_queue) => match next_queue.next() { + None => { + self.traversal_queue.pop_front(); + continue; + } + Some(next) => { + let (value, children) = next.$get_value_and_children(); + match children { + None => {} + Some(children) => self.traversal_queue.push_back(children), } + return Some(value); } - } + }, } - } + }, } } }; @@ -55,7 +52,7 @@ macro_rules! bfs_advance_iterator { } else { self.traversal_stack.get_mut(stack_len - 1).unwrap() }; - + match tree_node.children.as_mut() { None => break, Some(children) => { @@ -73,34 +70,37 @@ macro_rules! bfs_advance_iterator { tree_node.children = None; // let the child be dropped from memory } - + if self.item_stack.len() > 1 { - let target = self.traversal_stack.get_mut(stack_len - 1).unwrap(); + let target = self + .traversal_stack + .get_mut(stack_len - 1) + .unwrap(); target.value = self.item_stack.pop(); } - - - if self.traversal_stack.len() == 0 { continue; } + + if self.traversal_stack.len() == 0 { + continue; + } let popped = self.traversal_stack.pop().unwrap(); stack_len -= 1; - + let parent = if stack_len < 1 { &mut self.tree_cache } else { self.traversal_stack.get_mut(stack_len - 1).unwrap() }; - - parent.children - .as_mut() - .unwrap() - .push_back(Some(popped)); + + parent.children.as_mut().unwrap().push_back(Some(popped)); } Some(mut value) => { - self.item_stack.push(core::mem::take(&mut value.value).unwrap()); + self.item_stack + .push(core::mem::take(&mut value.value).unwrap()); let has_children = !value.children.is_none(); self.traversal_stack.push(value); stack_len += 1; - if !has_children && self.item_stack.len() >= starting_depth { + if !has_children && self.item_stack.len() >= starting_depth + { break; } else { continue; @@ -113,40 +113,32 @@ macro_rules! bfs_advance_iterator { } } } - + fn pop_from_item_stack(&mut self) { - if self.item_stack.len() == 1 { return; } + if self.item_stack.len() == 1 { + return; + } let tree_node = match self.item_stack.len() { 0 | 1 => panic!("item stack len should never be 0 or 1 here!"), - 2 => { - &mut self.tree_cache - } - _ => { - self.traversal_stack.get_mut( - self.item_stack.len() - 3 - ).unwrap() - } + 2 => &mut self.tree_cache, + _ => self + .traversal_stack + .get_mut(self.item_stack.len() - 3) + .unwrap(), }; - + let children = match &mut tree_node.children { None => { tree_node.children = Some(VecDeque::new()); tree_node.children.as_mut().unwrap() } - Some(children) => { - children - } + Some(children) => children, }; - - children.push_back( - Some( - TreeNodeVecDeque { - value: Some(self.item_stack.pop().unwrap()), - children: None, - } - ) - ); - + + children.push_back(Some(TreeNodeVecDeque { + value: Some(self.item_stack.pop().unwrap()), + children: None, + })); } }; } @@ -158,7 +150,7 @@ macro_rules! bfs_streaming_iterator_impl { self.is_root = false; return; } - + loop { match self.iterator_queue.get_mut(0) { None => { @@ -188,24 +180,28 @@ macro_rules! bfs_streaming_iterator_impl { let stack_len = self.traversal_stack.len(); self.traversal_stack.get_mut(stack_len - 1).unwrap() }; - + match &mut top_of_traversal_stack.children { Some(children) => children.push_front(None), // used up all the value, so just pop it None => { - while self.traversal_stack.len() > 0 - && (self.traversal_stack + while self.traversal_stack.len() > 0 + && (self + .traversal_stack .get(self.traversal_stack.len() - 1) .unwrap() .children - .is_none() - || self.traversal_stack - .get(self.traversal_stack.len() - 1) - .unwrap() - .children - .as_ref() - .unwrap() - .len() == 1) { + .is_none() + || self + .traversal_stack + .get(self.traversal_stack.len() - 1) + .unwrap() + .children + .as_ref() + .unwrap() + .len() + == 1) + { self.traversal_stack.pop(); self.item_stack.pop(); } @@ -241,13 +237,13 @@ macro_rules! get_mut { }; } -pub(crate) use bfs_next; pub(crate) use bfs_advance_iterator; +pub(crate) use bfs_next; pub(crate) use bfs_streaming_iterator_impl; pub(crate) use get_mut; #[derive(Debug, Default, Clone)] -struct TreeNodeVecDeque { - value: Option, - children: Option>>, -} \ No newline at end of file +pub(crate) struct TreeNodeVecDeque { + pub(crate) value: Option, + pub(crate) children: Option>>, +} diff --git a/src/bfs_iterators/mut_borrow.rs b/src/bfs_iterators/mut_borrow.rs index 9ea987f..ce90c71 100644 --- a/src/bfs_iterators/mut_borrow.rs +++ b/src/bfs_iterators/mut_borrow.rs @@ -1,62 +1,52 @@ -use alloc::{ - collections::VecDeque, - vec::Vec -}; -use streaming_iterator::{ - StreamingIterator, - StreamingIteratorMut -}; +use alloc::{collections::VecDeque, vec::Vec}; +use streaming_iterator::{StreamingIterator, StreamingIteratorMut}; +use super::{ + bfs_advance_iterator, bfs_next, bfs_streaming_iterator_impl, get_mut, TreeNodeVecDeque, +}; use crate::{ + leaves_iterators::{ + ancestors_breadth_first::mut_borrow::{ + MutBorrowedBFSLeavesIteratorWithAncestors, + MutBorrowedBinaryBFSLeavesIteratorWithAncestors, + }, + breadth_first::mut_borrow::{MutBorrowedBinaryLeavesIterator, MutBorrowedLeavesIterator}, + }, prelude::{ - MutBorrowedTreeNode, - BinaryChildren, - MutBorrowedBinaryTreeNode, - AncestorsIterator, - AncestorsIteratorMut, - LeavesIterator, - TreeIteratorMut - }, - leaves_iterators::breadth_first::mut_borrow::{ - MutBorrowedLeavesIterator, - MutBorrowedBinaryLeavesIterator + AncestorsIteratorMut, AncestorsLeavesIteratorMut, BinaryChildren, LeavesIterator, + MutBorrowedBinaryTreeNode, MutBorrowedTreeNode, TreeIteratorMut, }, }; -use super::{ - get_mut, - bfs_next, - bfs_advance_iterator, - bfs_streaming_iterator_impl, - TreeNodeVecDeque, -}; - - -pub struct MutBorrowedBFSIterator<'a, Node> - where Node: MutBorrowedTreeNode<'a> { +pub struct MutBorrowedBFSIterator<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ root: Option<&'a mut Node>, - traversal_queue: VecDeque + traversal_queue: VecDeque, } impl<'a, Node> MutBorrowedBFSIterator<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - - pub (crate) fn new(root: &'a mut Node) -> MutBorrowedBFSIterator<'a, Node> { - MutBorrowedBFSIterator { - root: Some(root), - traversal_queue: VecDeque::new() +where + Node: MutBorrowedTreeNode<'a>, +{ + pub(crate) fn new(root: &'a mut Node) -> MutBorrowedBFSIterator<'a, Node> { + MutBorrowedBFSIterator { + root: Some(root), + traversal_queue: VecDeque::new(), } } } -impl<'a, Node> TreeIteratorMut for MutBorrowedBFSIterator<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - +impl<'a, Node> TreeIteratorMut for MutBorrowedBFSIterator<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ fn leaves(self) -> impl LeavesIterator { - MutBorrowedLeavesIterator { - root: self.root, + MutBorrowedLeavesIterator { + root: self.root, old_traversal_queue: self.traversal_queue, - new_traversal_queue: VecDeque::new() + new_traversal_queue: VecDeque::new(), } } @@ -68,26 +58,29 @@ impl<'a, Node> TreeIteratorMut for MutBorrowedBFSIterator<'a, Node> } } -impl<'a, Node> Iterator for MutBorrowedBFSIterator<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - +impl<'a, Node> Iterator for MutBorrowedBFSIterator<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ type Item = Node::MutBorrowedValue; bfs_next!(get_value_and_children_iter_mut); } -pub struct MutBorrowedBFSIteratorWithAncestors<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - - is_root: bool, - item_stack: Vec, - tree_cache: TreeNodeVecDeque, - traversal_stack: Vec>, - iterator_queue: VecDeque>, +pub struct MutBorrowedBFSIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ + pub(crate) is_root: bool, + pub(crate) item_stack: Vec, + pub(crate) tree_cache: TreeNodeVecDeque, + pub(crate) traversal_stack: Vec>, + pub(crate) iterator_queue: VecDeque>, } -impl<'a, Node> MutBorrowedBFSIteratorWithAncestors<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - +impl<'a, Node> MutBorrowedBFSIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ fn new(root: &'a mut Node) -> MutBorrowedBFSIteratorWithAncestors<'a, Node> { let (value, children) = root.get_value_and_children_iter_mut(); let tree_cache = TreeNodeVecDeque { @@ -112,49 +105,58 @@ impl<'a, Node> MutBorrowedBFSIteratorWithAncestors<'a, Node> bfs_advance_iterator!(get_value_and_children_iter_mut); } -impl<'a, Node> StreamingIterator for MutBorrowedBFSIteratorWithAncestors<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - +impl<'a, Node> StreamingIterator for MutBorrowedBFSIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ type Item = [Node::MutBorrowedValue]; bfs_streaming_iterator_impl!(get_value_and_children_iter_mut); } -impl<'a, Node> StreamingIteratorMut for MutBorrowedBFSIteratorWithAncestors<'a, Node> - where Node: MutBorrowedTreeNode<'a> { +impl<'a, Node> StreamingIteratorMut for MutBorrowedBFSIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ get_mut!(); } -impl<'a, Node> AncestorsIterator for MutBorrowedBFSIteratorWithAncestors<'a, Node> - where Node: MutBorrowedTreeNode<'a> {} - -impl<'a, Node> AncestorsIteratorMut for MutBorrowedBFSIteratorWithAncestors<'a, Node> - where Node: MutBorrowedTreeNode<'a> {} - -pub struct MutBorrowedBinaryBFSIterator<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { +impl<'a, Node> AncestorsIteratorMut for MutBorrowedBFSIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ + fn leaves(self) -> impl AncestorsLeavesIteratorMut { + MutBorrowedBFSLeavesIteratorWithAncestors::new(self) + } +} +pub struct MutBorrowedBinaryBFSIterator<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ root: Option<&'a mut Node>, - traversal_queue: VecDeque> + traversal_queue: VecDeque>, } impl<'a, Node> MutBorrowedBinaryBFSIterator<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - - pub (crate) fn new(root: &'a mut Node) -> MutBorrowedBinaryBFSIterator<'a, Node> { - MutBorrowedBinaryBFSIterator { - root: Some(root), - traversal_queue: VecDeque::new() +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ + pub(crate) fn new(root: &'a mut Node) -> MutBorrowedBinaryBFSIterator<'a, Node> { + MutBorrowedBinaryBFSIterator { + root: Some(root), + traversal_queue: VecDeque::new(), } } } -impl<'a, Node> TreeIteratorMut for MutBorrowedBinaryBFSIterator<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +impl<'a, Node> TreeIteratorMut for MutBorrowedBinaryBFSIterator<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ fn leaves(self) -> impl LeavesIterator { - MutBorrowedBinaryLeavesIterator { - root: self.root, + MutBorrowedBinaryLeavesIterator { + root: self.root, old_traversal_queue: self.traversal_queue, new_traversal_queue: VecDeque::new(), } @@ -168,26 +170,29 @@ impl<'a, Node> TreeIteratorMut for MutBorrowedBinaryBFSIterator<'a, Node> } } -impl<'a, Node> Iterator for MutBorrowedBinaryBFSIterator<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +impl<'a, Node> Iterator for MutBorrowedBinaryBFSIterator<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ type Item = Node::MutBorrowedValue; bfs_next!(get_value_and_children_iter_mut); } -pub struct MutBorrowedBinaryBFSIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - - is_root: bool, - item_stack: Vec, - tree_cache: TreeNodeVecDeque, - traversal_stack: Vec>, - iterator_queue: VecDeque>>, +pub struct MutBorrowedBinaryBFSIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ + pub(crate) is_root: bool, + pub(crate) item_stack: Vec, + pub(crate) tree_cache: TreeNodeVecDeque, + pub(crate) traversal_stack: Vec>, + pub(crate) iterator_queue: VecDeque>>, } -impl<'a, Node> MutBorrowedBinaryBFSIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +impl<'a, Node> MutBorrowedBinaryBFSIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ fn new(root: &'a mut Node) -> MutBorrowedBinaryBFSIteratorWithAncestors<'a, Node> { let (value, children) = root.get_value_and_children_iter_mut(); let tree_cache = TreeNodeVecDeque { @@ -212,22 +217,27 @@ impl<'a, Node> MutBorrowedBinaryBFSIteratorWithAncestors<'a, Node> bfs_advance_iterator!(get_value_and_children_iter_mut); } -impl<'a, Node> StreamingIterator for MutBorrowedBinaryBFSIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +impl<'a, Node> StreamingIterator for MutBorrowedBinaryBFSIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ type Item = [Node::MutBorrowedValue]; bfs_streaming_iterator_impl!(get_value_and_children_iter_mut); } -impl<'a, Node> StreamingIteratorMut for MutBorrowedBinaryBFSIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +impl<'a, Node> StreamingIteratorMut for MutBorrowedBinaryBFSIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ get_mut!(); } -impl<'a, Node> AncestorsIterator for MutBorrowedBinaryBFSIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> {} - -impl<'a, Node> AncestorsIteratorMut for MutBorrowedBinaryBFSIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> {} \ No newline at end of file +impl<'a, Node> AncestorsIteratorMut for MutBorrowedBinaryBFSIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ + fn leaves(self) -> impl AncestorsLeavesIteratorMut { + MutBorrowedBinaryBFSLeavesIteratorWithAncestors::new(self) + } +} diff --git a/src/bfs_iterators/owned.rs b/src/bfs_iterators/owned.rs index 55f3876..2521e24 100644 --- a/src/bfs_iterators/owned.rs +++ b/src/bfs_iterators/owned.rs @@ -1,63 +1,54 @@ -use alloc::{ - collections::VecDeque, - vec::Vec -}; -use streaming_iterator::{ - StreamingIterator, - StreamingIteratorMut -}; +use alloc::{collections::VecDeque, vec::Vec}; +use streaming_iterator::{StreamingIterator, StreamingIteratorMut}; +use super::{ + bfs_advance_iterator, bfs_next, bfs_streaming_iterator_impl, get_mut, TreeNodeVecDeque, +}; use crate::{ + leaves_iterators::{ + ancestors_breadth_first::owned::{ + OwnedBFSLeavesIteratorWithAncestors, OwnedBinaryBFSLeavesIteratorWithAncestors, + }, + breadth_first::owned::{OwnedBinaryLeavesIterator, OwnedLeavesIterator}, + }, prelude::{ - OwnedTreeNode, - BinaryChildren, - OwnedBinaryTreeNode, - TreeIteratorMut, - LeavesIterator, - AncestorsIterator, - AncestorsIteratorMut - }, - leaves_iterators::breadth_first::owned::{ - OwnedBinaryLeavesIterator, - OwnedLeavesIterator - } -}; -use super::{ - bfs_next, - bfs_advance_iterator, - bfs_streaming_iterator_impl, - TreeNodeVecDeque, get_mut, + AncestorsIteratorMut, AncestorsLeavesIteratorMut, BinaryChildren, LeavesIterator, + OwnedBinaryTreeNode, OwnedTreeNode, TreeIteratorMut, + }, }; -pub struct OwnedBFSIterator - where Node: OwnedTreeNode { - +pub struct OwnedBFSIterator +where + Node: OwnedTreeNode, +{ root: Option, - traversal_queue: VecDeque + traversal_queue: VecDeque, } impl OwnedBFSIterator - where Node: OwnedTreeNode { - - pub (crate) fn new(root: Node) -> OwnedBFSIterator { - OwnedBFSIterator { - root: Some(root), - traversal_queue: VecDeque::new() +where + Node: OwnedTreeNode, +{ + pub(crate) fn new(root: Node) -> OwnedBFSIterator { + OwnedBFSIterator { + root: Some(root), + traversal_queue: VecDeque::new(), } } } -impl TreeIteratorMut for OwnedBFSIterator - where Node: OwnedTreeNode { - +impl TreeIteratorMut for OwnedBFSIterator +where + Node: OwnedTreeNode, +{ fn leaves(self) -> impl LeavesIterator { - OwnedLeavesIterator { - root: self.root, + OwnedLeavesIterator { + root: self.root, old_traversal_queue: self.traversal_queue, new_traversal_queue: VecDeque::new(), } } - + fn attach_ancestors(self) -> impl AncestorsIteratorMut { match self.root { None => panic!("Attempted to attach metadata to a BFS iterator in the middle of a tree traversal. This is forbidden."), @@ -66,26 +57,29 @@ impl TreeIteratorMut for OwnedBFSIterator } } -impl Iterator for OwnedBFSIterator - where Node: OwnedTreeNode { - +impl Iterator for OwnedBFSIterator +where + Node: OwnedTreeNode, +{ type Item = Node::OwnedValue; bfs_next!(get_value_and_children); } -pub struct OwnedBFSIteratorWithAncestors - where Node: OwnedTreeNode { - - is_root: bool, - item_stack: Vec, - tree_cache: TreeNodeVecDeque, - traversal_stack: Vec>, - iterator_queue: VecDeque>, +pub struct OwnedBFSIteratorWithAncestors +where + Node: OwnedTreeNode, +{ + pub(crate) is_root: bool, + pub(crate) item_stack: Vec, + pub(crate) tree_cache: TreeNodeVecDeque, + pub(crate) traversal_stack: Vec>, + pub(crate) iterator_queue: VecDeque>, } -impl<'a, Node> OwnedBFSIteratorWithAncestors - where Node: OwnedTreeNode { - +impl<'a, Node> OwnedBFSIteratorWithAncestors +where + Node: OwnedTreeNode, +{ fn new(root: Node) -> OwnedBFSIteratorWithAncestors { let (value, children) = root.get_value_and_children(); let tree_cache = TreeNodeVecDeque { @@ -110,50 +104,58 @@ impl<'a, Node> OwnedBFSIteratorWithAncestors bfs_advance_iterator!(get_value_and_children); } -impl<'a, Node> StreamingIterator for OwnedBFSIteratorWithAncestors - where Node: OwnedTreeNode { - +impl<'a, Node> StreamingIterator for OwnedBFSIteratorWithAncestors +where + Node: OwnedTreeNode, +{ type Item = [Node::OwnedValue]; bfs_streaming_iterator_impl!(get_value_and_children); } -impl<'a, Node> StreamingIteratorMut for OwnedBFSIteratorWithAncestors - where Node: OwnedTreeNode { - +impl<'a, Node> StreamingIteratorMut for OwnedBFSIteratorWithAncestors +where + Node: OwnedTreeNode, +{ get_mut!(); } -impl AncestorsIterator for OwnedBFSIteratorWithAncestors - where Node: OwnedTreeNode {} - -impl AncestorsIteratorMut for OwnedBFSIteratorWithAncestors - where Node: OwnedTreeNode {} - -pub struct OwnedBinaryBFSIterator - where Node: OwnedBinaryTreeNode { +impl AncestorsIteratorMut for OwnedBFSIteratorWithAncestors +where + Node: OwnedTreeNode, +{ + fn leaves(self) -> impl AncestorsLeavesIteratorMut { + OwnedBFSLeavesIteratorWithAncestors::new(self) + } +} +pub struct OwnedBinaryBFSIterator +where + Node: OwnedBinaryTreeNode, +{ root: Option, - traversal_queue: VecDeque> + traversal_queue: VecDeque>, } impl OwnedBinaryBFSIterator - where Node: OwnedBinaryTreeNode { - - pub (crate) fn new(root: Node) -> OwnedBinaryBFSIterator { - OwnedBinaryBFSIterator { - root: Some(root), - traversal_queue: VecDeque::new() +where + Node: OwnedBinaryTreeNode, +{ + pub(crate) fn new(root: Node) -> OwnedBinaryBFSIterator { + OwnedBinaryBFSIterator { + root: Some(root), + traversal_queue: VecDeque::new(), } } } impl TreeIteratorMut for OwnedBinaryBFSIterator - where Node: OwnedBinaryTreeNode { - +where + Node: OwnedBinaryTreeNode, +{ fn leaves(self) -> impl LeavesIterator { - OwnedBinaryLeavesIterator { - root: self.root, + OwnedBinaryLeavesIterator { + root: self.root, old_traversal_queue: self.traversal_queue, new_traversal_queue: VecDeque::new(), } @@ -167,26 +169,29 @@ impl TreeIteratorMut for OwnedBinaryBFSIterator } } -impl Iterator for OwnedBinaryBFSIterator - where Node: OwnedBinaryTreeNode { - +impl Iterator for OwnedBinaryBFSIterator +where + Node: OwnedBinaryTreeNode, +{ type Item = Node::OwnedValue; bfs_next!(get_value_and_children); } -pub struct OwnedBinaryBFSIteratorWithAncestors - where Node: OwnedBinaryTreeNode { - - is_root: bool, - item_stack: Vec, - tree_cache: TreeNodeVecDeque, - traversal_stack: Vec>, - iterator_queue: VecDeque>>, +pub struct OwnedBinaryBFSIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, +{ + pub(crate) is_root: bool, + pub(crate) item_stack: Vec, + pub(crate) tree_cache: TreeNodeVecDeque, + pub(crate) traversal_stack: Vec>, + pub(crate) iterator_queue: VecDeque>>, } -impl<'a, Node> OwnedBinaryBFSIteratorWithAncestors - where Node: OwnedBinaryTreeNode { - +impl<'a, Node> OwnedBinaryBFSIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, +{ fn new(root: Node) -> OwnedBinaryBFSIteratorWithAncestors { let (value, children) = root.get_value_and_children(); let tree_cache = TreeNodeVecDeque { @@ -211,22 +216,32 @@ impl<'a, Node> OwnedBinaryBFSIteratorWithAncestors bfs_advance_iterator!(get_value_and_children); } -impl<'a, Node> StreamingIterator for OwnedBinaryBFSIteratorWithAncestors - where Node: OwnedBinaryTreeNode { +impl AncestorsIteratorMut for OwnedBinaryBFSIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, +{ + fn leaves(self) -> impl AncestorsLeavesIteratorMut { + OwnedBinaryBFSLeavesIteratorWithAncestors::new(self) + } +} +impl<'a, Node> StreamingIterator for OwnedBinaryBFSIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, +{ type Item = [Node::OwnedValue]; bfs_streaming_iterator_impl!(get_value_and_children); } -impl<'a, Node> StreamingIteratorMut for OwnedBinaryBFSIteratorWithAncestors - where Node: OwnedBinaryTreeNode { - +impl<'a, Node> StreamingIteratorMut for OwnedBinaryBFSIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, +{ get_mut!(); } -impl AncestorsIterator for OwnedBinaryBFSIteratorWithAncestors - where Node: OwnedBinaryTreeNode {} - -impl AncestorsIteratorMut for OwnedBinaryBFSIteratorWithAncestors - where Node: OwnedBinaryTreeNode {} \ No newline at end of file +impl AncestorsLeavesIteratorMut for OwnedBinaryBFSIteratorWithAncestors where + Node: OwnedBinaryTreeNode +{ +} diff --git a/src/dfs_inorder_iterators/borrow.rs b/src/dfs_inorder_iterators/borrow.rs index 8dfd267..770e283 100644 --- a/src/dfs_inorder_iterators/borrow.rs +++ b/src/dfs_inorder_iterators/borrow.rs @@ -2,33 +2,32 @@ use alloc::vec::Vec; use streaming_iterator::StreamingIterator; use crate::{ + leaves_iterators::{ + ancestors_depth_first::borrow::BorrowedBinaryDFSLeavesPostorderIteratorWithAncestors, + depth_first::borrow::BorrowedBinaryLeavesIterator, + }, prelude::{ - BorrowedBinaryTreeNode, - TreeIterator, - AncestorsIterator, - LeavesIterator - }, - leaves_iterators::depth_first::borrow::BorrowedBinaryLeavesIterator, + AncestorsIterator, AncestorsLeavesIterator, BorrowedBinaryTreeNode, LeavesIterator, + TreeIterator, + }, }; -use super::{ - dfs_inorder_next, - dfs_inorder_streaming_iterator_impl, - TraversalStatus -}; +use super::{dfs_inorder_next, dfs_inorder_streaming_iterator_impl, TraversalStatus}; -pub struct BorrowedDFSInorderIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +pub struct BorrowedDFSInorderIterator<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ right_stack: Vec>, item_stack: Vec, moved: bool, } -impl<'a, Node> BorrowedDFSInorderIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - - pub (crate) fn new(root: &'a Node) -> BorrowedDFSInorderIterator<'a, Node> { +impl<'a, Node> BorrowedDFSInorderIterator<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ + pub(crate) fn new(root: &'a Node) -> BorrowedDFSInorderIterator<'a, Node> { let mut right_stack = Vec::new(); right_stack.push(Some(root)); @@ -40,7 +39,10 @@ impl<'a, Node> BorrowedDFSInorderIterator<'a, Node> } } -impl<'a, Node> TreeIterator for BorrowedDFSInorderIterator<'a, Node> where Node: BorrowedBinaryTreeNode<'a> { +impl<'a, Node> TreeIterator for BorrowedDFSInorderIterator<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ fn leaves(self) -> impl LeavesIterator { let mut traversal_stack_bottom = Vec::with_capacity(self.right_stack.capacity()); for opt in self.right_stack { @@ -65,25 +67,28 @@ impl<'a, Node> TreeIterator for BorrowedDFSInorderIterator<'a, Node> where Node: } impl<'a, Node> Iterator for BorrowedDFSInorderIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +where + Node: BorrowedBinaryTreeNode<'a>, +{ type Item = Node::BorrowedValue; - + dfs_inorder_next!(get_value_and_children_binary_iter); } -pub struct BorrowedDFSInorderIteratorWithAncestors<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +pub struct BorrowedDFSInorderIteratorWithAncestors<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ right_stack: Vec>, item_stack: Vec, status_stack: Vec, } -impl<'a, Node> BorrowedDFSInorderIteratorWithAncestors<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - - pub (crate) fn new(root: &'a Node) -> BorrowedDFSInorderIteratorWithAncestors { +impl<'a, Node> BorrowedDFSInorderIteratorWithAncestors<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ + pub(crate) fn new(root: &'a Node) -> BorrowedDFSInorderIteratorWithAncestors { let mut right_stack = Vec::new(); right_stack.push(Some(root)); @@ -96,12 +101,39 @@ impl<'a, Node> BorrowedDFSInorderIteratorWithAncestors<'a, Node> } impl<'a, Node> StreamingIterator for BorrowedDFSInorderIteratorWithAncestors<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +where + Node: BorrowedBinaryTreeNode<'a>, +{ type Item = [Node::BorrowedValue]; - + dfs_inorder_streaming_iterator_impl!(get_value_and_children_binary_iter); } impl<'a, Node> AncestorsIterator for BorrowedDFSInorderIteratorWithAncestors<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> {} \ No newline at end of file +where + Node: BorrowedBinaryTreeNode<'a>, +{ + fn leaves(mut self) -> impl AncestorsLeavesIterator { + let root; + let old_traversal_stack; + + if self.right_stack.len() == 1 { + root = core::mem::take(self.right_stack.get_mut(0).unwrap()); + old_traversal_stack = Vec::new(); + } else { + root = None; + old_traversal_stack = self + .right_stack + .into_iter() + .map(|opt| opt.into_iter()) + .collect(); + } + + BorrowedBinaryDFSLeavesPostorderIteratorWithAncestors { + root, + item_stack: self.item_stack, + old_traversal_stack, + new_traversal_stack: Vec::new(), + } + } +} diff --git a/src/dfs_inorder_iterators/mod.rs b/src/dfs_inorder_iterators/mod.rs index 4ae18b5..cc06c22 100644 --- a/src/dfs_inorder_iterators/mod.rs +++ b/src/dfs_inorder_iterators/mod.rs @@ -1,6 +1,6 @@ -pub mod owned; -pub mod mut_borrow; pub mod borrow; +pub mod mut_borrow; +pub mod owned; macro_rules! dfs_inorder_next { ($get_value_and_left_right: ident) => { @@ -11,8 +11,8 @@ macro_rules! dfs_inorder_next { current = match current { Some(c) => Some(c), None => { - if self.right_stack.len() == self.item_stack.len() { - return self.item_stack.pop(); + if self.right_stack.len() == self.item_stack.len() { + return self.item_stack.pop(); } match self.right_stack.pop() { Some(right) => right, @@ -20,18 +20,20 @@ macro_rules! dfs_inorder_next { } } }; - - if self.right_stack.len() == 0 { break; } + + if self.right_stack.len() == 0 { + break; + } } - + while let Some(current_val) = current { let (value, [left, right]) = current_val.$get_value_and_left_right(); - + self.right_stack.push(right); self.item_stack.push(value); current = left; } - + self.item_stack.pop() } }; @@ -41,17 +43,19 @@ macro_rules! dfs_inorder_streaming_iterator_impl { ($get_value_and_left_right: ident) => { fn advance(&mut self) { let mut current = None; - while current.is_none() { - if self.right_stack.len() == 0 { + while current.is_none() { + if self.right_stack.len() == 0 { self.item_stack.clear(); break; } - while self.status_stack.len() > 0 && self.status_stack[self.status_stack.len() - 1] == TraversalStatus::WentRight { + while self.status_stack.len() > 0 + && self.status_stack[self.status_stack.len() - 1] == TraversalStatus::WentRight + { self.item_stack.pop(); self.status_stack.pop(); } - + if self.status_stack.len() > 0 { let len = self.status_stack.len(); match self.status_stack.get_mut(len - 1) { @@ -75,7 +79,10 @@ macro_rules! dfs_inorder_streaming_iterator_impl { match self.right_stack.pop() { Some(right) => right, None => { - while self.status_stack.len() > 0 && self.status_stack[self.status_stack.len() - 1] == TraversalStatus::WentRight { + while self.status_stack.len() > 0 + && self.status_stack[self.status_stack.len() - 1] + == TraversalStatus::WentRight + { self.item_stack.pop(); self.status_stack.pop(); } @@ -85,10 +92,10 @@ macro_rules! dfs_inorder_streaming_iterator_impl { } }; } - + while let Some(current_val) = current { let (value, [left, right]) = current_val.$get_value_and_left_right(); - + self.right_stack.push(right); self.item_stack.push(value); self.status_stack.push(TraversalStatus::WentLeft); @@ -100,7 +107,7 @@ macro_rules! dfs_inorder_streaming_iterator_impl { self.status_stack[len - 1] = TraversalStatus::ReturnedSelf; } } - + fn get(&self) -> Option<&Self::Item> { if self.item_stack.len() > 0 { Some(self.item_stack.as_slice()) @@ -128,12 +135,12 @@ macro_rules! get_mut { /// in one direction /// WentLeft -> ReturnedSelf -> WentRight. #[derive(PartialEq, Eq)] -pub (crate) enum TraversalStatus { +pub(crate) enum TraversalStatus { WentLeft, ReturnedSelf, WentRight, } -pub (crate) use get_mut; -pub (crate) use dfs_inorder_next; -pub (crate) use dfs_inorder_streaming_iterator_impl; \ No newline at end of file +pub(crate) use dfs_inorder_next; +pub(crate) use dfs_inorder_streaming_iterator_impl; +pub(crate) use get_mut; diff --git a/src/dfs_inorder_iterators/mut_borrow.rs b/src/dfs_inorder_iterators/mut_borrow.rs index cbd2c31..775a249 100644 --- a/src/dfs_inorder_iterators/mut_borrow.rs +++ b/src/dfs_inorder_iterators/mut_borrow.rs @@ -1,39 +1,33 @@ use alloc::vec::Vec; -use streaming_iterator::{ - StreamingIterator, - StreamingIteratorMut -}; +use streaming_iterator::{StreamingIterator, StreamingIteratorMut}; use crate::{ + leaves_iterators::{ + ancestors_depth_first::mut_borrow::MutBorrowedBinaryDFSLeavesPostorderIteratorWithAncestors, + depth_first::mut_borrow::MutBorrowedBinaryLeavesIterator, + }, prelude::{ - MutBorrowedBinaryTreeNode, - LeavesIterator, - AncestorsIterator, - TreeIteratorMut, - AncestorsIteratorMut - }, - leaves_iterators::depth_first::mut_borrow::MutBorrowedBinaryLeavesIterator, + AncestorsIteratorMut, AncestorsLeavesIteratorMut, LeavesIterator, + MutBorrowedBinaryTreeNode, TreeIteratorMut, + }, }; -use super::{ - get_mut, - dfs_inorder_next, - dfs_inorder_streaming_iterator_impl, - TraversalStatus -}; +use super::{dfs_inorder_next, dfs_inorder_streaming_iterator_impl, get_mut, TraversalStatus}; -pub struct MutBorrowedDFSInorderIterator<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +pub struct MutBorrowedDFSInorderIterator<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ right_stack: Vec>, item_stack: Vec, - moved: bool + moved: bool, } -impl<'a, Node> MutBorrowedDFSInorderIterator<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - - pub (crate) fn new(root: &'a mut Node) -> MutBorrowedDFSInorderIterator<'a, Node> { +impl<'a, Node> MutBorrowedDFSInorderIterator<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ + pub(crate) fn new(root: &'a mut Node) -> MutBorrowedDFSInorderIterator<'a, Node> { let mut right_stack = Vec::new(); right_stack.push(Some(root)); @@ -45,9 +39,10 @@ impl<'a, Node> MutBorrowedDFSInorderIterator<'a, Node> } } -impl<'a, Node> TreeIteratorMut for MutBorrowedDFSInorderIterator<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +impl<'a, Node> TreeIteratorMut for MutBorrowedDFSInorderIterator<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ fn leaves(self) -> impl LeavesIterator { let mut traversal_stack_bottom = Vec::with_capacity(self.right_stack.capacity()); for opt in self.right_stack { @@ -72,25 +67,28 @@ impl<'a, Node> TreeIteratorMut for MutBorrowedDFSInorderIterator<'a, Node> } impl<'a, Node> Iterator for MutBorrowedDFSInorderIterator<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ type Item = Node::MutBorrowedValue; - + dfs_inorder_next!(get_value_and_children_binary_iter_mut); } -pub struct MutBorrowedDFSInorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +pub struct MutBorrowedDFSInorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ right_stack: Vec>, item_stack: Vec, status_stack: Vec, } -impl<'a, Node> MutBorrowedDFSInorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - - pub (crate) fn new(root: &'a mut Node) -> MutBorrowedDFSInorderIteratorWithAncestors<'a, Node> { +impl<'a, Node> MutBorrowedDFSInorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ + pub(crate) fn new(root: &'a mut Node) -> MutBorrowedDFSInorderIteratorWithAncestors<'a, Node> { let mut right_stack = Vec::new(); right_stack.push(Some(root)); @@ -103,21 +101,46 @@ impl<'a, Node> MutBorrowedDFSInorderIteratorWithAncestors<'a, Node> } impl<'a, Node> StreamingIterator for MutBorrowedDFSInorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ type Item = [Node::MutBorrowedValue]; - + dfs_inorder_streaming_iterator_impl!(get_value_and_children_binary_iter_mut); } -impl<'a, Node> StreamingIteratorMut for MutBorrowedDFSInorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +impl<'a, Node> StreamingIteratorMut for MutBorrowedDFSInorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ get_mut!(); } -impl<'a, Node> AncestorsIterator for MutBorrowedDFSInorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> {} +impl<'a, Node> AncestorsIteratorMut for MutBorrowedDFSInorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ + fn leaves(mut self) -> impl AncestorsLeavesIteratorMut { + let root; + let old_traversal_stack; + + if self.right_stack.len() == 1 { + root = core::mem::take(self.right_stack.get_mut(0).unwrap()); + old_traversal_stack = Vec::new(); + } else { + root = None; + old_traversal_stack = self + .right_stack + .into_iter() + .map(|opt| opt.into_iter()) + .collect(); + } -impl<'a, Node> AncestorsIteratorMut for MutBorrowedDFSInorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> {} \ No newline at end of file + MutBorrowedBinaryDFSLeavesPostorderIteratorWithAncestors { + root, + item_stack: self.item_stack, + old_traversal_stack, + new_traversal_stack: Vec::new(), + } + } +} diff --git a/src/dfs_inorder_iterators/owned.rs b/src/dfs_inorder_iterators/owned.rs index 6da3391..63f8c56 100644 --- a/src/dfs_inorder_iterators/owned.rs +++ b/src/dfs_inorder_iterators/owned.rs @@ -1,37 +1,32 @@ -use alloc::vec::Vec; use crate::{ + leaves_iterators::{ + ancestors_depth_first::owned::OwnedBinaryDFSLeavesPostorderIteratorWithAncestors, + depth_first::owned::OwnedBinaryLeavesIterator, + }, prelude::{ - OwnedBinaryTreeNode, - LeavesIterator, - AncestorsIterator, - AncestorsIteratorMut, TreeIteratorMut - }, - leaves_iterators::depth_first::owned::OwnedBinaryLeavesIterator, -}; -use streaming_iterator::{ - StreamingIterator, - StreamingIteratorMut + AncestorsIteratorMut, AncestorsLeavesIteratorMut, LeavesIterator, OwnedBinaryTreeNode, + TreeIteratorMut, + }, }; +use alloc::vec::Vec; +use streaming_iterator::{StreamingIterator, StreamingIteratorMut}; -use super::{ - get_mut, - dfs_inorder_next, - dfs_inorder_streaming_iterator_impl, - TraversalStatus -}; +use super::{dfs_inorder_next, dfs_inorder_streaming_iterator_impl, get_mut, TraversalStatus}; -pub struct OwnedDFSInorderIterator - where Node: OwnedBinaryTreeNode { - +pub struct OwnedDFSInorderIterator +where + Node: OwnedBinaryTreeNode, +{ right_stack: Vec>, item_stack: Vec, moved: bool, } -impl OwnedDFSInorderIterator - where Node: OwnedBinaryTreeNode { - - pub (crate) fn new(root: Node) -> OwnedDFSInorderIterator { +impl OwnedDFSInorderIterator +where + Node: OwnedBinaryTreeNode, +{ + pub(crate) fn new(root: Node) -> OwnedDFSInorderIterator { let mut right_stack = Vec::new(); right_stack.push(Some(root)); @@ -43,9 +38,10 @@ impl OwnedDFSInorderIterator } } -impl TreeIteratorMut for OwnedDFSInorderIterator - where Node: OwnedBinaryTreeNode { - +impl TreeIteratorMut for OwnedDFSInorderIterator +where + Node: OwnedBinaryTreeNode, +{ fn leaves(self) -> impl LeavesIterator { let mut traversal_stack_bottom = Vec::with_capacity(self.right_stack.capacity()); for opt in self.right_stack { @@ -70,25 +66,28 @@ impl TreeIteratorMut for OwnedDFSInorderIterator } impl Iterator for OwnedDFSInorderIterator - where Node: OwnedBinaryTreeNode { - +where + Node: OwnedBinaryTreeNode, +{ type Item = Node::OwnedValue; - + dfs_inorder_next!(get_value_and_children_binary); } -pub struct OwnedDFSInorderIteratorWithAncestors - where Node: OwnedBinaryTreeNode { - +pub struct OwnedDFSInorderIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, +{ right_stack: Vec>, item_stack: Vec, status_stack: Vec, } -impl OwnedDFSInorderIteratorWithAncestors - where Node: OwnedBinaryTreeNode { - - pub (crate) fn new(root: Node) -> OwnedDFSInorderIteratorWithAncestors { +impl OwnedDFSInorderIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, +{ + pub(crate) fn new(root: Node) -> OwnedDFSInorderIteratorWithAncestors { let mut right_stack = Vec::new(); right_stack.push(Some(root)); @@ -101,21 +100,46 @@ impl OwnedDFSInorderIteratorWithAncestors } impl StreamingIterator for OwnedDFSInorderIteratorWithAncestors - where Node: OwnedBinaryTreeNode { - +where + Node: OwnedBinaryTreeNode, +{ type Item = [Node::OwnedValue]; - + dfs_inorder_streaming_iterator_impl!(get_value_and_children_binary); } impl StreamingIteratorMut for OwnedDFSInorderIteratorWithAncestors - where Node: OwnedBinaryTreeNode { - +where + Node: OwnedBinaryTreeNode, +{ get_mut!(); } -impl AncestorsIterator for OwnedDFSInorderIteratorWithAncestors - where Node: OwnedBinaryTreeNode {} +impl AncestorsIteratorMut for OwnedDFSInorderIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, +{ + fn leaves(mut self) -> impl AncestorsLeavesIteratorMut { + let root; + let old_traversal_stack; + + if self.right_stack.len() == 1 { + root = core::mem::take(self.right_stack.get_mut(0).unwrap()); + old_traversal_stack = Vec::new(); + } else { + root = None; + old_traversal_stack = self + .right_stack + .into_iter() + .map(|opt| opt.into_iter()) + .collect(); + } -impl AncestorsIteratorMut for OwnedDFSInorderIteratorWithAncestors - where Node: OwnedBinaryTreeNode {} \ No newline at end of file + OwnedBinaryDFSLeavesPostorderIteratorWithAncestors { + root, + item_stack: self.item_stack, + old_traversal_stack, + new_traversal_stack: Vec::new(), + } + } +} diff --git a/src/dfs_postorder_iterators/borrow.rs b/src/dfs_postorder_iterators/borrow.rs index 55e6ca6..746e54e 100644 --- a/src/dfs_postorder_iterators/borrow.rs +++ b/src/dfs_postorder_iterators/borrow.rs @@ -1,53 +1,56 @@ -use alloc::vec::Vec; -use streaming_iterator::StreamingIterator; use crate::{ + leaves_iterators::{ + ancestors_depth_first::borrow::{ + BorrowedBinaryDFSLeavesPostorderIteratorWithAncestors, + BorrowedDFSLeavesPostorderIteratorWithAncestors, + }, + depth_first::borrow::{BorrowedBinaryLeavesIterator, BorrowedLeavesIterator}, + }, prelude::{ - BorrowedTreeNode, - BinaryChildren, - BorrowedBinaryTreeNode, TreeIterator, LeavesIterator, AncestorsIterator - }, - leaves_iterators::depth_first::borrow::{ - BorrowedLeavesIterator, - BorrowedBinaryLeavesIterator - } -}; - -use super::{ - postorder_streaming_iterator_impl, - dfs_postorder_next + AncestorsIterator, AncestorsLeavesIterator, BinaryChildren, BorrowedBinaryTreeNode, + BorrowedTreeNode, LeavesIterator, TreeIterator, + }, }; +use alloc::vec::Vec; +use streaming_iterator::StreamingIterator; -pub struct BorrowedDFSPostorderIterator<'a, Node> - where Node: BorrowedTreeNode<'a> { +use super::{dfs_postorder_next, postorder_streaming_iterator_impl}; +pub struct BorrowedDFSPostorderIterator<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ root: Option<&'a Node>, item_stack: Vec, - traversal_stack: Vec + traversal_stack: Vec, } -impl<'a, Node> BorrowedDFSPostorderIterator<'a, Node> - where Node: BorrowedTreeNode<'a> { - - pub (crate) fn new(root: &'a Node) -> BorrowedDFSPostorderIterator<'a, Node> { - BorrowedDFSPostorderIterator { +impl<'a, Node> BorrowedDFSPostorderIterator<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ + pub(crate) fn new(root: &'a Node) -> BorrowedDFSPostorderIterator<'a, Node> { + BorrowedDFSPostorderIterator { root: Some(root), - item_stack: Vec::new(), - traversal_stack: Vec::new() + item_stack: Vec::new(), + traversal_stack: Vec::new(), } } } -impl<'a, Node> TreeIterator for BorrowedDFSPostorderIterator<'a, Node> - where Node: BorrowedTreeNode<'a> { +impl<'a, Node> TreeIterator for BorrowedDFSPostorderIterator<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ fn leaves(self) -> impl LeavesIterator { - BorrowedLeavesIterator { + BorrowedLeavesIterator { root: self.root, traversal_stack_bottom: self.traversal_stack, traversal_stack_top: Vec::new(), item_stack: Vec::new(), } } - + fn attach_ancestors(self) -> impl AncestorsIterator { match self.root { None => panic!("Attempted to attach metadata to a DFS postorder iterator in the middle of a tree traversal. This is forbidden."), @@ -58,24 +61,27 @@ impl<'a, Node> TreeIterator for BorrowedDFSPostorderIterator<'a, Node> } } -impl<'a, Node> Iterator for BorrowedDFSPostorderIterator<'a, Node> - where Node: BorrowedTreeNode<'a> { - +impl<'a, Node> Iterator for BorrowedDFSPostorderIterator<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ type Item = Node::BorrowedValue; dfs_postorder_next!(get_value_and_children_iter); } pub struct BorrowedDFSPostorderIteratorWithAncestors<'a, Node> - where Node: BorrowedTreeNode<'a> { - +where + Node: BorrowedTreeNode<'a>, +{ root: Option<&'a Node>, item_stack: Vec, traversal_stack: Vec, } -impl<'a, Node> BorrowedDFSPostorderIteratorWithAncestors<'a, Node> - where Node: BorrowedTreeNode<'a> { - +impl<'a, Node> BorrowedDFSPostorderIteratorWithAncestors<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ fn new(root: &'a Node) -> BorrowedDFSPostorderIteratorWithAncestors<'_, Node> { Self { root: Some(root), @@ -85,48 +91,63 @@ impl<'a, Node> BorrowedDFSPostorderIteratorWithAncestors<'a, Node> } } -impl<'a, Node> StreamingIterator for BorrowedDFSPostorderIteratorWithAncestors<'a, Node> - where Node: BorrowedTreeNode<'a> { - +impl<'a, Node> StreamingIterator for BorrowedDFSPostorderIteratorWithAncestors<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ type Item = [Node::BorrowedValue]; postorder_streaming_iterator_impl!(get_value_and_children_iter); } -impl<'a, Node> AncestorsIterator for BorrowedDFSPostorderIteratorWithAncestors<'a, Node> - where Node: BorrowedTreeNode<'a> {} - -pub struct BorrowedBinaryDFSPostorderIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { +impl<'a, Node> AncestorsIterator for BorrowedDFSPostorderIteratorWithAncestors<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ + fn leaves(self) -> impl AncestorsLeavesIterator { + BorrowedDFSLeavesPostorderIteratorWithAncestors { + root: self.root, + item_stack: self.item_stack, + old_traversal_stack: self.traversal_stack.into_iter().collect(), + new_traversal_stack: Vec::new(), + } + } +} +pub struct BorrowedBinaryDFSPostorderIterator<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ root: Option<&'a Node>, item_stack: Vec, - traversal_stack: Vec> + traversal_stack: Vec>, } -impl<'a, Node> BorrowedBinaryDFSPostorderIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - - pub (crate) fn new(root: &'a Node) -> BorrowedBinaryDFSPostorderIterator<'a, Node> { - BorrowedBinaryDFSPostorderIterator { +impl<'a, Node> BorrowedBinaryDFSPostorderIterator<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ + pub(crate) fn new(root: &'a Node) -> BorrowedBinaryDFSPostorderIterator<'a, Node> { + BorrowedBinaryDFSPostorderIterator { root: Some(root), - item_stack: Vec::new(), - traversal_stack: Vec::new() + item_stack: Vec::new(), + traversal_stack: Vec::new(), } } } -impl<'a, Node> TreeIterator for BorrowedBinaryDFSPostorderIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +impl<'a, Node> TreeIterator for BorrowedBinaryDFSPostorderIterator<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ fn leaves(self) -> impl LeavesIterator { - BorrowedBinaryLeavesIterator { - root: self.root, + BorrowedBinaryLeavesIterator { + root: self.root, traversal_stack_bottom: self.traversal_stack, traversal_stack_top: Vec::new(), item_stack: Vec::new(), } } - + fn attach_ancestors(self) -> impl AncestorsIterator { match self.root { None => panic!("Attempted to attach metadata to a DFS postorder iterator in the middle of a tree traversal. This is forbidden."), @@ -137,24 +158,27 @@ impl<'a, Node> TreeIterator for BorrowedBinaryDFSPostorderIterator<'a, Node> } } -impl<'a, Node> Iterator for BorrowedBinaryDFSPostorderIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +impl<'a, Node> Iterator for BorrowedBinaryDFSPostorderIterator<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ type Item = Node::BorrowedValue; dfs_postorder_next!(get_value_and_children_iter); } pub struct BorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +where + Node: BorrowedBinaryTreeNode<'a>, +{ root: Option<&'a Node>, item_stack: Vec, traversal_stack: Vec>, } -impl<'a, Node> BorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +impl<'a, Node> BorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ fn new(root: &'a Node) -> BorrowedBinaryDFSPostorderIteratorWithAncestors<'_, Node> { Self { root: Some(root), @@ -164,12 +188,24 @@ impl<'a, Node> BorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> } } -impl<'a, Node> StreamingIterator for BorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +impl<'a, Node> StreamingIterator for BorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ type Item = [Node::BorrowedValue]; postorder_streaming_iterator_impl!(get_value_and_children_iter); } -impl<'a, Node> AncestorsIterator for BorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> {} \ No newline at end of file +impl<'a, Node> AncestorsIterator for BorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ + fn leaves(self) -> impl AncestorsLeavesIterator { + BorrowedBinaryDFSLeavesPostorderIteratorWithAncestors { + root: self.root, + item_stack: self.item_stack, + old_traversal_stack: self.traversal_stack.into_iter().collect(), + new_traversal_stack: Vec::new(), + } + } +} diff --git a/src/dfs_postorder_iterators/mod.rs b/src/dfs_postorder_iterators/mod.rs index 36ebd79..d557e94 100644 --- a/src/dfs_postorder_iterators/mod.rs +++ b/src/dfs_postorder_iterators/mod.rs @@ -1,6 +1,6 @@ -pub mod owned; -pub mod mut_borrow; pub mod borrow; +pub mod mut_borrow; +pub mod owned; macro_rules! dfs_postorder_next { ($get_value_and_children: ident) => { @@ -10,38 +10,40 @@ macro_rules! dfs_postorder_next { Some(next) => { let (value, children) = next.$get_value_and_children(); match children { - None => { return Some(value); } + None => { + return Some(value); + } Some(children) => { self.traversal_stack.push(children); self.item_stack.push(value); } } } - None => { - loop { - let stack_len = self.traversal_stack.len(); - if stack_len < 1 { return None; } - match self.traversal_stack.get_mut(stack_len - 1) { - None => return self.item_stack.pop(), - Some(next_iter) => { - match next_iter.next() { + None => loop { + let stack_len = self.traversal_stack.len(); + if stack_len < 1 { + return None; + } + match self.traversal_stack.get_mut(stack_len - 1) { + None => return self.item_stack.pop(), + Some(next_iter) => match next_iter.next() { + None => { + self.traversal_stack.pop(); + return self.item_stack.pop(); + } + Some(node) => { + let (value, children) = node.$get_value_and_children(); + self.item_stack.push(value); + match children { None => { - self.traversal_stack.pop(); return self.item_stack.pop(); } - Some(node) => { - let (value, children) = node.$get_value_and_children(); - self.item_stack.push(value); - match children { - None => { return self.item_stack.pop(); } - Some(children) => self.traversal_stack.push(children) - } - } + Some(children) => self.traversal_stack.push(children), } } - } + }, } - } + }, } } } @@ -69,42 +71,44 @@ macro_rules! postorder_streaming_iterator_impl { let mut pushed_another_iterator = false; loop { let stack_len = self.traversal_stack.len(); - if stack_len < 1 { + if stack_len < 1 { self.item_stack.pop(); - return; + return; } match self.traversal_stack.get_mut(stack_len - 1) { - None => { - self.item_stack.pop(); - return; + None => { + self.item_stack.pop(); + return; } - Some(next_iter) => { - match next_iter.next() { - None => { - if self.item_stack.len() > self.traversal_stack.len() { - self.item_stack.pop(); - } - self.traversal_stack.pop(); - return; + Some(next_iter) => match next_iter.next() { + None => { + if self.item_stack.len() > self.traversal_stack.len() { + self.item_stack.pop(); } - Some(node) => { - let (value, children) = node.$get_value_and_children(); - match children { - None => { - if !pushed_another_iterator { self.item_stack.pop(); } - self.item_stack.push(value); - return; + self.traversal_stack.pop(); + return; + } + Some(node) => { + let (value, children) = node.$get_value_and_children(); + match children { + None => { + if !pushed_another_iterator { + self.item_stack.pop(); } - Some(children) => { - if is_first_iteration { self.item_stack.pop(); } - self.traversal_stack.push(children); - self.item_stack.push(value); - pushed_another_iterator = true; + self.item_stack.push(value); + return; + } + Some(children) => { + if is_first_iteration { + self.item_stack.pop(); } + self.traversal_stack.push(children); + self.item_stack.push(value); + pushed_another_iterator = true; } } } - } + }, } is_first_iteration = false; } @@ -135,6 +139,6 @@ macro_rules! get_mut { }; } -pub(crate) use get_mut; pub(crate) use dfs_postorder_next; -pub(crate) use postorder_streaming_iterator_impl; \ No newline at end of file +pub(crate) use get_mut; +pub(crate) use postorder_streaming_iterator_impl; diff --git a/src/dfs_postorder_iterators/mut_borrow.rs b/src/dfs_postorder_iterators/mut_borrow.rs index dcafc5d..a949b2f 100644 --- a/src/dfs_postorder_iterators/mut_borrow.rs +++ b/src/dfs_postorder_iterators/mut_borrow.rs @@ -1,59 +1,53 @@ -use alloc::vec::Vec; -use streaming_iterator::{ - StreamingIterator, - StreamingIteratorMut -}; use crate::{ + leaves_iterators::{ + ancestors_depth_first::mut_borrow::{ + MutBorrowedBinaryDFSLeavesPostorderIteratorWithAncestors, + MutBorrowedDFSLeavesPostorderIteratorWithAncestors, + }, + depth_first::mut_borrow::{MutBorrowedBinaryLeavesIterator, MutBorrowedLeavesIterator}, + }, prelude::{ - MutBorrowedTreeNode, - BinaryChildren, - MutBorrowedBinaryTreeNode, - LeavesIterator, - TreeIteratorMut, - AncestorsIterator, - AncestorsIteratorMut - }, - leaves_iterators::depth_first::mut_borrow::{ - MutBorrowedLeavesIterator, - MutBorrowedBinaryLeavesIterator - } -}; - -use super::{ - get_mut, - dfs_postorder_next, - postorder_streaming_iterator_impl + AncestorsIteratorMut, AncestorsLeavesIteratorMut, BinaryChildren, LeavesIterator, + MutBorrowedBinaryTreeNode, MutBorrowedTreeNode, TreeIteratorMut, + }, }; +use alloc::vec::Vec; +use streaming_iterator::{StreamingIterator, StreamingIteratorMut}; -pub struct MutBorrowedDFSPostorderIterator<'a, Node> - where Node: MutBorrowedTreeNode<'a> { +use super::{dfs_postorder_next, get_mut, postorder_streaming_iterator_impl}; +pub struct MutBorrowedDFSPostorderIterator<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ root: Option<&'a mut Node>, item_stack: Vec, - traversal_stack: Vec + traversal_stack: Vec, } -impl<'a, Node> MutBorrowedDFSPostorderIterator<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - - pub (crate) fn new(root: &'a mut Node) -> MutBorrowedDFSPostorderIterator<'a, Node> { - MutBorrowedDFSPostorderIterator { +impl<'a, Node> MutBorrowedDFSPostorderIterator<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ + pub(crate) fn new(root: &'a mut Node) -> MutBorrowedDFSPostorderIterator<'a, Node> { + MutBorrowedDFSPostorderIterator { root: Some(root), - item_stack: Vec::new(), - traversal_stack: Vec::new() + item_stack: Vec::new(), + traversal_stack: Vec::new(), } } } -impl<'a, Node> TreeIteratorMut for MutBorrowedDFSPostorderIterator<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - +impl<'a, Node> TreeIteratorMut for MutBorrowedDFSPostorderIterator<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ fn leaves(self) -> impl LeavesIterator { - MutBorrowedLeavesIterator { + MutBorrowedLeavesIterator { root: self.root, traversal_stack_bottom: self.traversal_stack, traversal_stack_top: Vec::new(), - item_stack: Vec::new() + item_stack: Vec::new(), } } @@ -67,24 +61,27 @@ impl<'a, Node> TreeIteratorMut for MutBorrowedDFSPostorderIterator<'a, Node> } } -impl<'a, Node> Iterator for MutBorrowedDFSPostorderIterator<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - +impl<'a, Node> Iterator for MutBorrowedDFSPostorderIterator<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ type Item = Node::MutBorrowedValue; dfs_postorder_next!(get_value_and_children_iter_mut); } pub struct MutBorrowedDFSPostorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - +where + Node: MutBorrowedTreeNode<'a>, +{ root: Option<&'a mut Node>, item_stack: Vec, traversal_stack: Vec, } -impl<'a, Node> MutBorrowedDFSPostorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - +impl<'a, Node> MutBorrowedDFSPostorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ fn new(root: &'a mut Node) -> MutBorrowedDFSPostorderIteratorWithAncestors<'_, Node> { Self { root: Some(root), @@ -94,54 +91,67 @@ impl<'a, Node> MutBorrowedDFSPostorderIteratorWithAncestors<'a, Node> } } -impl<'a, Node> StreamingIterator for MutBorrowedDFSPostorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - +impl<'a, Node> StreamingIterator for MutBorrowedDFSPostorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ type Item = [Node::MutBorrowedValue]; postorder_streaming_iterator_impl!(get_value_and_children_iter_mut); } -impl<'a, Node> StreamingIteratorMut for MutBorrowedDFSPostorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - +impl<'a, Node> StreamingIteratorMut for MutBorrowedDFSPostorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ get_mut!(); } -impl<'a, Node> AncestorsIterator for MutBorrowedDFSPostorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedTreeNode<'a> {} - -impl<'a, Node> AncestorsIteratorMut for MutBorrowedDFSPostorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedTreeNode<'a> {} - -pub struct MutBorrowedBinaryDFSPostorderIterator<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { +impl<'a, Node> AncestorsIteratorMut for MutBorrowedDFSPostorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ + fn leaves(self) -> impl AncestorsLeavesIteratorMut { + MutBorrowedDFSLeavesPostorderIteratorWithAncestors { + root: self.root, + item_stack: self.item_stack, + old_traversal_stack: self.traversal_stack.into_iter().collect(), + new_traversal_stack: Vec::new(), + } + } +} +pub struct MutBorrowedBinaryDFSPostorderIterator<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ root: Option<&'a mut Node>, item_stack: Vec, - traversal_stack: Vec> + traversal_stack: Vec>, } -impl<'a, Node> MutBorrowedBinaryDFSPostorderIterator<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - - pub (crate) fn new(root: &'a mut Node) -> MutBorrowedBinaryDFSPostorderIterator<'a, Node> { - MutBorrowedBinaryDFSPostorderIterator { +impl<'a, Node> MutBorrowedBinaryDFSPostorderIterator<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ + pub(crate) fn new(root: &'a mut Node) -> MutBorrowedBinaryDFSPostorderIterator<'a, Node> { + MutBorrowedBinaryDFSPostorderIterator { root: Some(root), - item_stack: Vec::new(), - traversal_stack: Vec::new() + item_stack: Vec::new(), + traversal_stack: Vec::new(), } } } -impl<'a, Node> TreeIteratorMut for MutBorrowedBinaryDFSPostorderIterator<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +impl<'a, Node> TreeIteratorMut for MutBorrowedBinaryDFSPostorderIterator<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ fn leaves(self) -> impl LeavesIterator { - MutBorrowedBinaryLeavesIterator { - root: self.root, + MutBorrowedBinaryLeavesIterator { + root: self.root, traversal_stack_bottom: self.traversal_stack, traversal_stack_top: Vec::new(), - item_stack: Vec::new() + item_stack: Vec::new(), } } @@ -155,24 +165,27 @@ impl<'a, Node> TreeIteratorMut for MutBorrowedBinaryDFSPostorderIterator<'a, Nod } } -impl<'a, Node> Iterator for MutBorrowedBinaryDFSPostorderIterator<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +impl<'a, Node> Iterator for MutBorrowedBinaryDFSPostorderIterator<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ type Item = Node::MutBorrowedValue; dfs_postorder_next!(get_value_and_children_iter_mut); } pub struct MutBorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ root: Option<&'a mut Node>, item_stack: Vec, traversal_stack: Vec>, } -impl<'a, Node> MutBorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +impl<'a, Node> MutBorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ fn new(root: &'a mut Node) -> MutBorrowedBinaryDFSPostorderIteratorWithAncestors<'_, Node> { Self { root: Some(root), @@ -182,21 +195,31 @@ impl<'a, Node> MutBorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> } } -impl<'a, Node> StreamingIterator for MutBorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +impl<'a, Node> StreamingIterator for MutBorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ type Item = [Node::MutBorrowedValue]; postorder_streaming_iterator_impl!(get_value_and_children_iter_mut); } -impl<'a, Node> StreamingIteratorMut for MutBorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +impl<'a, Node> StreamingIteratorMut for MutBorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ get_mut!(); } -impl<'a, Node> AncestorsIterator for MutBorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> {} - -impl<'a, Node> AncestorsIteratorMut for MutBorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> {} \ No newline at end of file +impl<'a, Node> AncestorsIteratorMut for MutBorrowedBinaryDFSPostorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ + fn leaves(self) -> impl AncestorsLeavesIteratorMut { + MutBorrowedBinaryDFSLeavesPostorderIteratorWithAncestors { + root: self.root, + item_stack: self.item_stack, + old_traversal_stack: self.traversal_stack.into_iter().collect(), + new_traversal_stack: Vec::new(), + } + } +} diff --git a/src/dfs_postorder_iterators/owned.rs b/src/dfs_postorder_iterators/owned.rs index b403a23..ca8418f 100644 --- a/src/dfs_postorder_iterators/owned.rs +++ b/src/dfs_postorder_iterators/owned.rs @@ -1,59 +1,53 @@ -use alloc::vec::Vec; -use streaming_iterator::{ - StreamingIterator, - StreamingIteratorMut -}; use crate::{ + leaves_iterators::{ + ancestors_depth_first::owned::{ + OwnedBinaryDFSLeavesPostorderIteratorWithAncestors, + OwnedDFSLeavesPostorderIteratorWithAncestors, + }, + depth_first::owned::{OwnedBinaryLeavesIterator, OwnedLeavesIterator}, + }, prelude::{ - OwnedTreeNode, - BinaryChildren, - OwnedBinaryTreeNode, - LeavesIterator, - AncestorsIterator, - AncestorsIteratorMut, - TreeIteratorMut - }, - leaves_iterators::depth_first::owned::{ - OwnedLeavesIterator, - OwnedBinaryLeavesIterator - } -}; - -use super::{ - get_mut, - dfs_postorder_next, - postorder_streaming_iterator_impl + AncestorsIteratorMut, AncestorsLeavesIteratorMut, BinaryChildren, LeavesIterator, + OwnedBinaryTreeNode, OwnedTreeNode, TreeIteratorMut, + }, }; +use alloc::vec::Vec; +use streaming_iterator::{StreamingIterator, StreamingIteratorMut}; -pub struct OwnedDFSPostorderIterator - where Node: OwnedTreeNode { +use super::{dfs_postorder_next, get_mut, postorder_streaming_iterator_impl}; +pub struct OwnedDFSPostorderIterator +where + Node: OwnedTreeNode, +{ root: Option, item_stack: Vec, - traversal_stack: Vec + traversal_stack: Vec, } -impl OwnedDFSPostorderIterator - where Node: OwnedTreeNode { - - pub (crate) fn new(root: Node) -> OwnedDFSPostorderIterator { - OwnedDFSPostorderIterator { +impl OwnedDFSPostorderIterator +where + Node: OwnedTreeNode, +{ + pub(crate) fn new(root: Node) -> OwnedDFSPostorderIterator { + OwnedDFSPostorderIterator { root: Some(root), - item_stack: Vec::new(), - traversal_stack: Vec::new() + item_stack: Vec::new(), + traversal_stack: Vec::new(), } } } -impl TreeIteratorMut for OwnedDFSPostorderIterator - where Node: OwnedTreeNode { - +impl TreeIteratorMut for OwnedDFSPostorderIterator +where + Node: OwnedTreeNode, +{ fn leaves(self) -> impl LeavesIterator { - OwnedLeavesIterator { + OwnedLeavesIterator { root: self.root, traversal_stack_bottom: self.traversal_stack, traversal_stack_top: Vec::new(), - item_stack: Vec::new() + item_stack: Vec::new(), } } @@ -67,24 +61,27 @@ impl TreeIteratorMut for OwnedDFSPostorderIterator } } -impl Iterator for OwnedDFSPostorderIterator - where Node: OwnedTreeNode { - +impl Iterator for OwnedDFSPostorderIterator +where + Node: OwnedTreeNode, +{ type Item = Node::OwnedValue; dfs_postorder_next!(get_value_and_children); } pub struct OwnedDFSPostorderIteratorWithAncestors - where Node: OwnedTreeNode { - +where + Node: OwnedTreeNode, +{ root: Option, item_stack: Vec, traversal_stack: Vec, } -impl<'a, Node> OwnedDFSPostorderIteratorWithAncestors - where Node: OwnedTreeNode { - +impl<'a, Node> OwnedDFSPostorderIteratorWithAncestors +where + Node: OwnedTreeNode, +{ fn new(root: Node) -> OwnedDFSPostorderIteratorWithAncestors { Self { root: Some(root), @@ -94,51 +91,64 @@ impl<'a, Node> OwnedDFSPostorderIteratorWithAncestors } } -impl StreamingIterator for OwnedDFSPostorderIteratorWithAncestors - where Node: OwnedTreeNode { - +impl StreamingIterator for OwnedDFSPostorderIteratorWithAncestors +where + Node: OwnedTreeNode, +{ type Item = [Node::OwnedValue]; postorder_streaming_iterator_impl!(get_value_and_children); } -impl StreamingIteratorMut for OwnedDFSPostorderIteratorWithAncestors - where Node: OwnedTreeNode { - +impl StreamingIteratorMut for OwnedDFSPostorderIteratorWithAncestors +where + Node: OwnedTreeNode, +{ get_mut!(); } -impl AncestorsIterator for OwnedDFSPostorderIteratorWithAncestors - where Node: OwnedTreeNode {} - impl AncestorsIteratorMut for OwnedDFSPostorderIteratorWithAncestors - where Node: OwnedTreeNode {} - -pub struct OwnedBinaryDFSPostorderIterator - where Node: OwnedBinaryTreeNode { +where + Node: OwnedTreeNode, +{ + fn leaves(self) -> impl AncestorsLeavesIteratorMut { + OwnedDFSLeavesPostorderIteratorWithAncestors { + root: self.root, + item_stack: self.item_stack, + old_traversal_stack: self.traversal_stack.into_iter().collect(), + new_traversal_stack: Vec::new(), + } + } +} +pub struct OwnedBinaryDFSPostorderIterator +where + Node: OwnedBinaryTreeNode, +{ root: Option, item_stack: Vec, - traversal_stack: Vec> + traversal_stack: Vec>, } -impl OwnedBinaryDFSPostorderIterator - where Node: OwnedBinaryTreeNode { - - pub (crate) fn new(root: Node) -> OwnedBinaryDFSPostorderIterator { - OwnedBinaryDFSPostorderIterator { +impl OwnedBinaryDFSPostorderIterator +where + Node: OwnedBinaryTreeNode, +{ + pub(crate) fn new(root: Node) -> OwnedBinaryDFSPostorderIterator { + OwnedBinaryDFSPostorderIterator { root: Some(root), - item_stack: Vec::new(), - traversal_stack: Vec::new() + item_stack: Vec::new(), + traversal_stack: Vec::new(), } } } -impl TreeIteratorMut for OwnedBinaryDFSPostorderIterator - where Node: OwnedBinaryTreeNode { - +impl TreeIteratorMut for OwnedBinaryDFSPostorderIterator +where + Node: OwnedBinaryTreeNode, +{ fn leaves(self) -> impl LeavesIterator { - OwnedBinaryLeavesIterator { - root: self.root, + OwnedBinaryLeavesIterator { + root: self.root, traversal_stack_bottom: self.traversal_stack, traversal_stack_top: Vec::new(), item_stack: Vec::new(), @@ -155,24 +165,27 @@ impl TreeIteratorMut for OwnedBinaryDFSPostorderIterator } } -impl Iterator for OwnedBinaryDFSPostorderIterator - where Node: OwnedBinaryTreeNode { - +impl Iterator for OwnedBinaryDFSPostorderIterator +where + Node: OwnedBinaryTreeNode, +{ type Item = Node::OwnedValue; dfs_postorder_next!(get_value_and_children); } pub struct OwnedBinaryDFSPostorderIteratorWithAncestors - where Node: OwnedBinaryTreeNode { - +where + Node: OwnedBinaryTreeNode, +{ root: Option, item_stack: Vec, traversal_stack: Vec>, } -impl<'a, Node> OwnedBinaryDFSPostorderIteratorWithAncestors - where Node: OwnedBinaryTreeNode { - +impl<'a, Node> OwnedBinaryDFSPostorderIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, +{ fn new(root: Node) -> OwnedBinaryDFSPostorderIteratorWithAncestors { Self { root: Some(root), @@ -182,21 +195,31 @@ impl<'a, Node> OwnedBinaryDFSPostorderIteratorWithAncestors } } -impl StreamingIterator for OwnedBinaryDFSPostorderIteratorWithAncestors - where Node: OwnedBinaryTreeNode { - +impl StreamingIterator for OwnedBinaryDFSPostorderIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, +{ type Item = [Node::OwnedValue]; postorder_streaming_iterator_impl!(get_value_and_children); } -impl StreamingIteratorMut for OwnedBinaryDFSPostorderIteratorWithAncestors - where Node: OwnedBinaryTreeNode { - +impl StreamingIteratorMut for OwnedBinaryDFSPostorderIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, +{ get_mut!(); } -impl AncestorsIterator for OwnedBinaryDFSPostorderIteratorWithAncestors - where Node: OwnedBinaryTreeNode {} - impl AncestorsIteratorMut for OwnedBinaryDFSPostorderIteratorWithAncestors - where Node: OwnedBinaryTreeNode {} \ No newline at end of file +where + Node: OwnedBinaryTreeNode, +{ + fn leaves(self) -> impl AncestorsLeavesIteratorMut { + OwnedBinaryDFSLeavesPostorderIteratorWithAncestors { + root: self.root, + item_stack: self.item_stack, + old_traversal_stack: self.traversal_stack.into_iter().collect(), + new_traversal_stack: Vec::new(), + } + } +} diff --git a/src/dfs_preorder_iterators/borrow.rs b/src/dfs_preorder_iterators/borrow.rs index 0eab9fe..05d787f 100644 --- a/src/dfs_preorder_iterators/borrow.rs +++ b/src/dfs_preorder_iterators/borrow.rs @@ -1,43 +1,45 @@ -use alloc::vec::Vec; -use streaming_iterator::StreamingIterator; use crate::{ + leaves_iterators::{ + ancestors_depth_first::borrow::{ + BorrowedBinaryDFSLeavesPostorderIteratorWithAncestors, + BorrowedDFSLeavesPostorderIteratorWithAncestors, + }, + depth_first::borrow::{BorrowedBinaryLeavesIterator, BorrowedLeavesIterator}, + }, prelude::{ - BorrowedTreeNode, - BinaryChildren, - BorrowedBinaryTreeNode, TreeIterator, AncestorsIterator, LeavesIterator - }, - leaves_iterators::depth_first::borrow::{ - BorrowedLeavesIterator, - BorrowedBinaryLeavesIterator + AncestorsIterator, AncestorsLeavesIterator, BinaryChildren, BorrowedBinaryTreeNode, + BorrowedTreeNode, LeavesIterator, TreeIterator, }, }; +use alloc::vec::Vec; +use streaming_iterator::StreamingIterator; -use super::{ - preorder_streaming_iterator_impl, - dfs_preorder_next, - advance_dfs -}; +use super::{advance_dfs, dfs_preorder_next, preorder_streaming_iterator_impl}; pub struct BorrowedDFSPreorderIterator<'a, Node> - where Node: BorrowedTreeNode<'a> { - +where + Node: BorrowedTreeNode<'a>, +{ root: Option<&'a Node>, traversal_stack: Vec, } -impl<'a, Node> BorrowedDFSPreorderIterator<'a, Node> - where Node: BorrowedTreeNode<'a> { - - pub (crate) fn new(root: &'a Node) -> BorrowedDFSPreorderIterator<'a, Node> { - BorrowedDFSPreorderIterator { +impl<'a, Node> BorrowedDFSPreorderIterator<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ + pub(crate) fn new(root: &'a Node) -> BorrowedDFSPreorderIterator<'a, Node> { + BorrowedDFSPreorderIterator { root: Some(root), - traversal_stack: Vec::new() + traversal_stack: Vec::new(), } } } -impl<'a, Node> TreeIterator for BorrowedDFSPreorderIterator<'a, Node> - where Node: BorrowedTreeNode<'a> { +impl<'a, Node> TreeIterator for BorrowedDFSPreorderIterator<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ fn leaves(self) -> impl LeavesIterator { BorrowedLeavesIterator { root: self.root, @@ -46,7 +48,7 @@ impl<'a, Node> TreeIterator for BorrowedDFSPreorderIterator<'a, Node> item_stack: Vec::new(), } } - + fn attach_ancestors(self) -> impl AncestorsIterator { match self.root { None => panic!("Attempted to attach metadata to a DFS preorder iterator in the middle of a tree traversal. This is forbidden."), @@ -57,27 +59,29 @@ impl<'a, Node> TreeIterator for BorrowedDFSPreorderIterator<'a, Node> } } -impl<'a, Node> Iterator for BorrowedDFSPreorderIterator<'a, Node> - where Node: BorrowedTreeNode<'a> { - +impl<'a, Node> Iterator for BorrowedDFSPreorderIterator<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ type Item = Node::BorrowedValue; dfs_preorder_next!(get_value_and_children_iter); } pub struct BorrowedDFSPreorderIteratorWithAncestors<'a, Node> - where Node: BorrowedTreeNode<'a> { - +where + Node: BorrowedTreeNode<'a>, +{ root: Option<&'a Node>, traversal_stack: Vec, item_stack: Vec, } - -impl<'a, Node> BorrowedDFSPreorderIteratorWithAncestors<'a, Node> - where Node: BorrowedTreeNode<'a> { - - pub (crate) fn new(root: &'a Node) -> BorrowedDFSPreorderIteratorWithAncestors<'a, Node> { - BorrowedDFSPreorderIteratorWithAncestors { +impl<'a, Node> BorrowedDFSPreorderIteratorWithAncestors<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ + pub(crate) fn new(root: &'a Node) -> BorrowedDFSPreorderIteratorWithAncestors<'a, Node> { + BorrowedDFSPreorderIteratorWithAncestors { root: Some(root), traversal_stack: Vec::new(), item_stack: Vec::new(), @@ -87,37 +91,52 @@ impl<'a, Node> BorrowedDFSPreorderIteratorWithAncestors<'a, Node> advance_dfs!(get_value_and_children_iter); } -impl<'a, Node> StreamingIterator for BorrowedDFSPreorderIteratorWithAncestors<'a, Node> - where Node: BorrowedTreeNode<'a> { - +impl<'a, Node> StreamingIterator for BorrowedDFSPreorderIteratorWithAncestors<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ type Item = [Node::BorrowedValue]; preorder_streaming_iterator_impl!(); } -impl<'a, Node> AncestorsIterator for BorrowedDFSPreorderIteratorWithAncestors<'a, Node> - where Node: BorrowedTreeNode<'a> {} - +impl<'a, Node> AncestorsIterator for BorrowedDFSPreorderIteratorWithAncestors<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ + fn leaves(self) -> impl AncestorsLeavesIterator { + BorrowedDFSLeavesPostorderIteratorWithAncestors { + root: self.root, + item_stack: self.item_stack, + old_traversal_stack: self.traversal_stack, + new_traversal_stack: Vec::new(), + } + } +} pub struct BorrowedBinaryDFSPreorderIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +where + Node: BorrowedBinaryTreeNode<'a>, +{ root: Option<&'a Node>, traversal_stack: Vec>, } -impl<'a, Node> BorrowedBinaryDFSPreorderIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - - pub (crate) fn new(root: &'a Node) -> BorrowedBinaryDFSPreorderIterator<'a, Node> { - BorrowedBinaryDFSPreorderIterator { +impl<'a, Node> BorrowedBinaryDFSPreorderIterator<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ + pub(crate) fn new(root: &'a Node) -> BorrowedBinaryDFSPreorderIterator<'a, Node> { + BorrowedBinaryDFSPreorderIterator { root: Some(root), - traversal_stack: Vec::new() + traversal_stack: Vec::new(), } } } -impl<'a, Node> TreeIterator for BorrowedBinaryDFSPreorderIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { +impl<'a, Node> TreeIterator for BorrowedBinaryDFSPreorderIterator<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ fn leaves(self) -> impl LeavesIterator { BorrowedBinaryLeavesIterator { root: self.root, @@ -126,7 +145,7 @@ impl<'a, Node> TreeIterator for BorrowedBinaryDFSPreorderIterator<'a, Node> item_stack: Vec::new(), } } - + fn attach_ancestors(self) -> impl AncestorsIterator { match self.root { None => panic!("Attempted to attach metadata to a DFS preorder iterator in the middle of a tree traversal. This is forbidden."), @@ -137,27 +156,29 @@ impl<'a, Node> TreeIterator for BorrowedBinaryDFSPreorderIterator<'a, Node> } } -impl<'a, Node> Iterator for BorrowedBinaryDFSPreorderIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +impl<'a, Node> Iterator for BorrowedBinaryDFSPreorderIterator<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ type Item = Node::BorrowedValue; dfs_preorder_next!(get_value_and_children_iter); } pub struct BorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +where + Node: BorrowedBinaryTreeNode<'a>, +{ root: Option<&'a Node>, traversal_stack: Vec>, item_stack: Vec, } - -impl<'a, Node> BorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - - pub (crate) fn new(root: &'a Node) -> BorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> { - BorrowedBinaryDFSPreorderIteratorWithAncestors { +impl<'a, Node> BorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ + pub(crate) fn new(root: &'a Node) -> BorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> { + BorrowedBinaryDFSPreorderIteratorWithAncestors { root: Some(root), traversal_stack: Vec::new(), item_stack: Vec::new(), @@ -167,12 +188,24 @@ impl<'a, Node> BorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> advance_dfs!(get_value_and_children_iter); } -impl<'a, Node> StreamingIterator for BorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +impl<'a, Node> StreamingIterator for BorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ type Item = [Node::BorrowedValue]; preorder_streaming_iterator_impl!(); } -impl<'a, Node> AncestorsIterator for BorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> {} +impl<'a, Node> AncestorsIterator for BorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ + fn leaves(self) -> impl AncestorsLeavesIterator { + BorrowedBinaryDFSLeavesPostorderIteratorWithAncestors { + root: self.root, + item_stack: self.item_stack, + old_traversal_stack: self.traversal_stack, + new_traversal_stack: Vec::new(), + } + } +} diff --git a/src/dfs_preorder_iterators/mod.rs b/src/dfs_preorder_iterators/mod.rs index c2cc756..0b37805 100644 --- a/src/dfs_preorder_iterators/mod.rs +++ b/src/dfs_preorder_iterators/mod.rs @@ -1,6 +1,6 @@ -pub mod owned; -pub mod mut_borrow; pub mod borrow; +pub mod mut_borrow; +pub mod owned; macro_rules! dfs_preorder_next { ($get_value_and_children: ident) => { @@ -10,16 +10,16 @@ macro_rules! dfs_preorder_next { let (value, children) = next.$get_value_and_children(); match children { None => {} - Some(children) => self.traversal_stack.push(children) + Some(children) => self.traversal_stack.push(children), } return Some(value); } None => { - let next; + let next; loop { let stack_len = self.traversal_stack.len(); - if stack_len == 0 { - next = None; + if stack_len == 0 { + next = None; break; } match self.traversal_stack.get_mut(stack_len - 1) { @@ -27,24 +27,22 @@ macro_rules! dfs_preorder_next { next = None; break; } - Some(top) => { - match top.next() { - None => { - self.traversal_stack.pop(); - } - Some(value) => { - next = Some(value); - break; - } + Some(top) => match top.next() { + None => { + self.traversal_stack.pop(); } - } + Some(value) => { + next = Some(value); + break; + } + }, } - }; + } match next { None => return None, Some(node) => { let (value, children) = node.$get_value_and_children(); - match children { + match children { None => {} Some(children) => self.traversal_stack.push(children), } @@ -65,9 +63,9 @@ macro_rules! advance_dfs { let (value, children) = next.$get_value_and_children(); match children { None => {} - Some(children) => self.traversal_stack.push(children) + Some(children) => self.traversal_stack.push(children), } - + self.item_stack.push(value); return; } @@ -75,8 +73,8 @@ macro_rules! advance_dfs { let next; loop { let stack_len = self.traversal_stack.len(); - if stack_len == 0 { - next = None; + if stack_len == 0 { + next = None; break; } match self.traversal_stack.get_mut(stack_len - 1) { @@ -105,7 +103,7 @@ macro_rules! advance_dfs { None => return, Some(node) => { let (value, children) = node.$get_value_and_children(); - match children { + match children { None => {} Some(children) => self.traversal_stack.push(children), } @@ -147,7 +145,7 @@ macro_rules! get_mut { }; } +pub(crate) use advance_dfs; +pub(crate) use dfs_preorder_next; pub(crate) use get_mut; -pub (crate) use dfs_preorder_next; -pub (crate) use advance_dfs; -pub (crate) use preorder_streaming_iterator_impl; \ No newline at end of file +pub(crate) use preorder_streaming_iterator_impl; diff --git a/src/dfs_preorder_iterators/mut_borrow.rs b/src/dfs_preorder_iterators/mut_borrow.rs index 616d386..9b72495 100644 --- a/src/dfs_preorder_iterators/mut_borrow.rs +++ b/src/dfs_preorder_iterators/mut_borrow.rs @@ -1,56 +1,49 @@ use alloc::vec::Vec; -use streaming_iterator::{ - StreamingIterator, - StreamingIteratorMut -}; +use streaming_iterator::{StreamingIterator, StreamingIteratorMut}; use crate::{ + leaves_iterators::{ + ancestors_depth_first::mut_borrow::{ + MutBorrowedBinaryDFSLeavesPostorderIteratorWithAncestors, + MutBorrowedDFSLeavesPostorderIteratorWithAncestors, + }, + depth_first::mut_borrow::{MutBorrowedBinaryLeavesIterator, MutBorrowedLeavesIterator}, + }, prelude::{ - MutBorrowedTreeNode, - BinaryChildren, - MutBorrowedBinaryTreeNode, - LeavesIterator, - AncestorsIterator, - TreeIteratorMut, - AncestorsIteratorMut - }, - leaves_iterators::depth_first::mut_borrow::{ - MutBorrowedLeavesIterator, - MutBorrowedBinaryLeavesIterator - } + AncestorsIteratorMut, AncestorsLeavesIteratorMut, BinaryChildren, LeavesIterator, + MutBorrowedBinaryTreeNode, MutBorrowedTreeNode, TreeIteratorMut, + }, }; -use super::{ - get_mut, - dfs_preorder_next, - preorder_streaming_iterator_impl, - advance_dfs -}; +use super::{advance_dfs, dfs_preorder_next, get_mut, preorder_streaming_iterator_impl}; pub struct MutBorrowedDFSPreorderIterator<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - +where + Node: MutBorrowedTreeNode<'a>, +{ root: Option<&'a mut Node>, traversal_stack: Vec, } -impl<'a, Node> MutBorrowedDFSPreorderIterator<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - - pub (crate) fn new(root: &'a mut Node) -> MutBorrowedDFSPreorderIterator<'a, Node> { - MutBorrowedDFSPreorderIterator { +impl<'a, Node> MutBorrowedDFSPreorderIterator<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ + pub(crate) fn new(root: &'a mut Node) -> MutBorrowedDFSPreorderIterator<'a, Node> { + MutBorrowedDFSPreorderIterator { root: Some(root), - traversal_stack: Vec::new() + traversal_stack: Vec::new(), } } } -impl<'a, Node> TreeIteratorMut for MutBorrowedDFSPreorderIterator<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - +impl<'a, Node> TreeIteratorMut for MutBorrowedDFSPreorderIterator<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ fn leaves(self) -> impl LeavesIterator { - MutBorrowedLeavesIterator { - root: self.root, + MutBorrowedLeavesIterator { + root: self.root, traversal_stack_bottom: self.traversal_stack, traversal_stack_top: Vec::new(), item_stack: Vec::new(), @@ -67,76 +60,91 @@ impl<'a, Node> TreeIteratorMut for MutBorrowedDFSPreorderIterator<'a, Node> } } -impl<'a, Node> Iterator for MutBorrowedDFSPreorderIterator<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - +impl<'a, Node> Iterator for MutBorrowedDFSPreorderIterator<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ type Item = Node::MutBorrowedValue; dfs_preorder_next!(get_value_and_children_iter_mut); } pub struct MutBorrowedDFSPreorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - +where + Node: MutBorrowedTreeNode<'a>, +{ root: Option<&'a mut Node>, traversal_stack: Vec, item_stack: Vec, } - -impl<'a, Node> MutBorrowedDFSPreorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - - pub (crate) fn new(root: &'a mut Node) -> MutBorrowedDFSPreorderIteratorWithAncestors<'a, Node> { - MutBorrowedDFSPreorderIteratorWithAncestors { +impl<'a, Node> MutBorrowedDFSPreorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ + pub(crate) fn new(root: &'a mut Node) -> MutBorrowedDFSPreorderIteratorWithAncestors<'a, Node> { + MutBorrowedDFSPreorderIteratorWithAncestors { root: Some(root), traversal_stack: Vec::new(), item_stack: Vec::new(), } } - + advance_dfs!(get_value_and_children_iter_mut); } -impl<'a, Node> StreamingIterator for MutBorrowedDFSPreorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - +impl<'a, Node> StreamingIterator for MutBorrowedDFSPreorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ type Item = [Node::MutBorrowedValue]; preorder_streaming_iterator_impl!(); } -impl<'a, Node> StreamingIteratorMut for MutBorrowedDFSPreorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - +impl<'a, Node> StreamingIteratorMut for MutBorrowedDFSPreorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ get_mut!(); } -impl<'a, Node> AncestorsIterator for MutBorrowedDFSPreorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedTreeNode<'a> {} - impl<'a, Node> AncestorsIteratorMut for MutBorrowedDFSPreorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedTreeNode<'a> {} +where + Node: MutBorrowedTreeNode<'a>, +{ + fn leaves(self) -> impl AncestorsLeavesIteratorMut { + MutBorrowedDFSLeavesPostorderIteratorWithAncestors { + root: self.root, + item_stack: self.item_stack, + old_traversal_stack: self.traversal_stack, + new_traversal_stack: Vec::new(), + } + } +} pub struct MutBorrowedBinaryDFSPreorderIterator<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ root: Option<&'a mut Node>, traversal_stack: Vec>, } -impl<'a, Node> MutBorrowedBinaryDFSPreorderIterator<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - - pub (crate) fn new(root: &'a mut Node) -> MutBorrowedBinaryDFSPreorderIterator<'a, Node> { - MutBorrowedBinaryDFSPreorderIterator { +impl<'a, Node> MutBorrowedBinaryDFSPreorderIterator<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ + pub(crate) fn new(root: &'a mut Node) -> MutBorrowedBinaryDFSPreorderIterator<'a, Node> { + MutBorrowedBinaryDFSPreorderIterator { root: Some(root), - traversal_stack: Vec::new() + traversal_stack: Vec::new(), } } } -impl<'a, Node> TreeIteratorMut for MutBorrowedBinaryDFSPreorderIterator<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +impl<'a, Node> TreeIteratorMut for MutBorrowedBinaryDFSPreorderIterator<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ fn leaves(self) -> impl LeavesIterator { MutBorrowedBinaryLeavesIterator { root: self.root, @@ -156,51 +164,65 @@ impl<'a, Node> TreeIteratorMut for MutBorrowedBinaryDFSPreorderIterator<'a, Node } } -impl<'a, Node> Iterator for MutBorrowedBinaryDFSPreorderIterator<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +impl<'a, Node> Iterator for MutBorrowedBinaryDFSPreorderIterator<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ type Item = Node::MutBorrowedValue; dfs_preorder_next!(get_value_and_children_iter_mut); } pub struct MutBorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ root: Option<&'a mut Node>, traversal_stack: Vec>, item_stack: Vec, } - -impl<'a, Node> MutBorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - - pub (crate) fn new(root: &'a mut Node) -> MutBorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> { - MutBorrowedBinaryDFSPreorderIteratorWithAncestors { +impl<'a, Node> MutBorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ + pub(crate) fn new( + root: &'a mut Node, + ) -> MutBorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> { + MutBorrowedBinaryDFSPreorderIteratorWithAncestors { root: Some(root), traversal_stack: Vec::new(), item_stack: Vec::new(), } } - + advance_dfs!(get_value_and_children_iter_mut); } -impl<'a, Node> StreamingIterator for MutBorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +impl<'a, Node> StreamingIterator for MutBorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ type Item = [Node::MutBorrowedValue]; preorder_streaming_iterator_impl!(); } -impl<'a, Node> StreamingIteratorMut for MutBorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> { - +impl<'a, Node> StreamingIteratorMut for MutBorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ get_mut!(); } -impl<'a, Node> AncestorsIterator for MutBorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> {} - -impl<'a, Node> AncestorsIteratorMut for MutBorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> - where Node: MutBorrowedBinaryTreeNode<'a> {} +impl<'a, Node> AncestorsIteratorMut for MutBorrowedBinaryDFSPreorderIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ + fn leaves(self) -> impl AncestorsLeavesIteratorMut { + MutBorrowedBinaryDFSLeavesPostorderIteratorWithAncestors { + root: self.root, + item_stack: self.item_stack, + old_traversal_stack: self.traversal_stack, + new_traversal_stack: Vec::new(), + } + } +} diff --git a/src/dfs_preorder_iterators/owned.rs b/src/dfs_preorder_iterators/owned.rs index 8285997..b14b700 100644 --- a/src/dfs_preorder_iterators/owned.rs +++ b/src/dfs_preorder_iterators/owned.rs @@ -1,54 +1,52 @@ use alloc::vec::Vec; -use streaming_iterator::{ - StreamingIterator, - StreamingIteratorMut -}; +use streaming_iterator::{StreamingIterator, StreamingIteratorMut}; use crate::{ + leaves_iterators::{ + ancestors_depth_first::owned::{ + OwnedBinaryDFSLeavesPostorderIteratorWithAncestors, + OwnedDFSLeavesPostorderIteratorWithAncestors, + }, + depth_first::owned::{OwnedBinaryLeavesIterator, OwnedLeavesIterator}, + }, prelude::{ - OwnedTreeNode, - BinaryChildren, - OwnedBinaryTreeNode, - LeavesIterator, - AncestorsIteratorMut, - AncestorsIterator, - TreeIteratorMut - }, - leaves_iterators::depth_first::owned::{ - OwnedLeavesIterator, - OwnedBinaryLeavesIterator - } + AncestorsIteratorMut, AncestorsLeavesIteratorMut, BinaryChildren, LeavesIterator, + OwnedBinaryTreeNode, OwnedTreeNode, TreeIteratorMut, + }, }; -use super::{dfs_preorder_next, preorder_streaming_iterator_impl, advance_dfs, get_mut}; +use super::{advance_dfs, dfs_preorder_next, get_mut, preorder_streaming_iterator_impl}; pub struct OwnedDFSPreorderIterator - where Node: OwnedTreeNode { - +where + Node: OwnedTreeNode, +{ root: Option, traversal_stack: Vec, } -impl OwnedDFSPreorderIterator - where Node: OwnedTreeNode { - - pub (crate) fn new(root: Node) -> OwnedDFSPreorderIterator { - OwnedDFSPreorderIterator { +impl OwnedDFSPreorderIterator +where + Node: OwnedTreeNode, +{ + pub(crate) fn new(root: Node) -> OwnedDFSPreorderIterator { + OwnedDFSPreorderIterator { root: Some(root), - traversal_stack: Vec::new() + traversal_stack: Vec::new(), } } } -impl TreeIteratorMut for OwnedDFSPreorderIterator - where Node: OwnedTreeNode { - +impl TreeIteratorMut for OwnedDFSPreorderIterator +where + Node: OwnedTreeNode, +{ fn leaves(self) -> impl LeavesIterator { OwnedLeavesIterator { root: self.root, traversal_stack_bottom: self.traversal_stack, traversal_stack_top: Vec::new(), - item_stack: Vec::new() + item_stack: Vec::new(), } } @@ -62,76 +60,91 @@ impl TreeIteratorMut for OwnedDFSPreorderIterator } } -impl Iterator for OwnedDFSPreorderIterator - where Node: OwnedTreeNode { - +impl Iterator for OwnedDFSPreorderIterator +where + Node: OwnedTreeNode, +{ type Item = Node::OwnedValue; dfs_preorder_next!(get_value_and_children); } pub struct OwnedDFSPreorderIteratorWithAncestors - where Node: OwnedTreeNode { - +where + Node: OwnedTreeNode, +{ root: Option, traversal_stack: Vec, item_stack: Vec, } - -impl<'a, Node> OwnedDFSPreorderIteratorWithAncestors - where Node: OwnedTreeNode { - - pub (crate) fn new(root: Node) -> OwnedDFSPreorderIteratorWithAncestors { - OwnedDFSPreorderIteratorWithAncestors { +impl<'a, Node> OwnedDFSPreorderIteratorWithAncestors +where + Node: OwnedTreeNode, +{ + pub(crate) fn new(root: Node) -> OwnedDFSPreorderIteratorWithAncestors { + OwnedDFSPreorderIteratorWithAncestors { root: Some(root), traversal_stack: Vec::new(), item_stack: Vec::new(), } } - + advance_dfs!(get_value_and_children); } -impl StreamingIterator for OwnedDFSPreorderIteratorWithAncestors - where Node: OwnedTreeNode { - +impl StreamingIterator for OwnedDFSPreorderIteratorWithAncestors +where + Node: OwnedTreeNode, +{ type Item = [Node::OwnedValue]; preorder_streaming_iterator_impl!(); } -impl StreamingIteratorMut for OwnedDFSPreorderIteratorWithAncestors - where Node: OwnedTreeNode { - +impl StreamingIteratorMut for OwnedDFSPreorderIteratorWithAncestors +where + Node: OwnedTreeNode, +{ get_mut!(); } -impl AncestorsIterator for OwnedDFSPreorderIteratorWithAncestors - where Node: OwnedTreeNode {} - -impl AncestorsIteratorMut for OwnedDFSPreorderIteratorWithAncestors - where Node: OwnedTreeNode {} +impl AncestorsIteratorMut for OwnedDFSPreorderIteratorWithAncestors +where + Node: OwnedTreeNode, +{ + fn leaves(self) -> impl AncestorsLeavesIteratorMut { + OwnedDFSLeavesPostorderIteratorWithAncestors { + root: self.root, + item_stack: self.item_stack, + old_traversal_stack: self.traversal_stack, + new_traversal_stack: Vec::new(), + } + } +} pub struct OwnedBinaryDFSPreorderIterator - where Node: OwnedBinaryTreeNode { - +where + Node: OwnedBinaryTreeNode, +{ root: Option, traversal_stack: Vec>, } -impl OwnedBinaryDFSPreorderIterator - where Node: OwnedBinaryTreeNode { - - pub (crate) fn new(root: Node) -> OwnedBinaryDFSPreorderIterator { - OwnedBinaryDFSPreorderIterator { +impl OwnedBinaryDFSPreorderIterator +where + Node: OwnedBinaryTreeNode, +{ + pub(crate) fn new(root: Node) -> OwnedBinaryDFSPreorderIterator { + OwnedBinaryDFSPreorderIterator { root: Some(root), - traversal_stack: Vec::new() + traversal_stack: Vec::new(), } } } -impl TreeIteratorMut for OwnedBinaryDFSPreorderIterator - where Node: OwnedBinaryTreeNode { - +impl TreeIteratorMut for OwnedBinaryDFSPreorderIterator +where + Node: OwnedBinaryTreeNode, +{ fn leaves(self) -> impl LeavesIterator { OwnedBinaryLeavesIterator { root: self.root, @@ -151,51 +164,63 @@ impl TreeIteratorMut for OwnedBinaryDFSPreorderIterator } } -impl Iterator for OwnedBinaryDFSPreorderIterator - where Node: OwnedBinaryTreeNode { - +impl Iterator for OwnedBinaryDFSPreorderIterator +where + Node: OwnedBinaryTreeNode, +{ type Item = Node::OwnedValue; dfs_preorder_next!(get_value_and_children); } pub struct OwnedBinaryDFSPreorderIteratorWithAncestors - where Node: OwnedBinaryTreeNode { - +where + Node: OwnedBinaryTreeNode, +{ root: Option, traversal_stack: Vec>, item_stack: Vec, } - -impl<'a, Node> OwnedBinaryDFSPreorderIteratorWithAncestors - where Node: OwnedBinaryTreeNode { - - pub (crate) fn new(root: Node) -> OwnedBinaryDFSPreorderIteratorWithAncestors { - OwnedBinaryDFSPreorderIteratorWithAncestors { +impl<'a, Node> OwnedBinaryDFSPreorderIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, +{ + pub(crate) fn new(root: Node) -> OwnedBinaryDFSPreorderIteratorWithAncestors { + OwnedBinaryDFSPreorderIteratorWithAncestors { root: Some(root), traversal_stack: Vec::new(), item_stack: Vec::new(), } } - + advance_dfs!(get_value_and_children); } -impl<'a, Node> StreamingIterator for OwnedBinaryDFSPreorderIteratorWithAncestors - where Node: OwnedBinaryTreeNode { - +impl<'a, Node> StreamingIterator for OwnedBinaryDFSPreorderIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, +{ type Item = [Node::OwnedValue]; preorder_streaming_iterator_impl!(); } -impl<'a, Node> StreamingIteratorMut for OwnedBinaryDFSPreorderIteratorWithAncestors - where Node: OwnedBinaryTreeNode { - +impl<'a, Node> StreamingIteratorMut for OwnedBinaryDFSPreorderIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, +{ get_mut!(); } -impl AncestorsIterator for OwnedBinaryDFSPreorderIteratorWithAncestors - where Node: OwnedBinaryTreeNode {} - impl AncestorsIteratorMut for OwnedBinaryDFSPreorderIteratorWithAncestors - where Node: OwnedBinaryTreeNode {} \ No newline at end of file +where + Node: OwnedBinaryTreeNode, +{ + fn leaves(self) -> impl AncestorsLeavesIteratorMut { + OwnedBinaryDFSLeavesPostorderIteratorWithAncestors { + root: self.root, + item_stack: self.item_stack, + old_traversal_stack: self.traversal_stack, + new_traversal_stack: Vec::new(), + } + } +} diff --git a/src/examples.rs b/src/examples.rs index 69f7ebc..1d026e2 100644 --- a/src/examples.rs +++ b/src/examples.rs @@ -2,90 +2,50 @@ use crate::prelude::*; use alloc::{boxed::Box, vec}; pub fn create_example_binary_tree() -> BinaryTreeNode { - BinaryTreeNode { - value: 0, - left: Some( - Box::new( - BinaryTreeNode { - value: 1, - left: Some( - Box::new( - BinaryTreeNode { - value: 3, - left: None, - right: None, - } - ) - ), - right: Some( - Box::new( - BinaryTreeNode { - value: 4, - left: None, - right: None, - } - ) - ), - } - ) - ), - right: Some( - Box::new( - BinaryTreeNode { - value: 2, - left: Some( - Box::new( - BinaryTreeNode { - value: 5, + BinaryTreeNode { + value: 0, + left: Some(Box::new(BinaryTreeNode { + value: 1, + left: Some(Box::new(BinaryTreeNode { + value: 3, + left: None, + right: None, + })), + right: Some(Box::new(BinaryTreeNode { + value: 4, + left: None, + right: None, + })), + })), + right: Some(Box::new(BinaryTreeNode { + value: 2, + left: Some(Box::new(BinaryTreeNode { + value: 5, + left: None, + right: None, + })), + right: Some(Box::new(BinaryTreeNode { + value: 6, + left: Some(Box::new(BinaryTreeNode { + value: 7, + left: None, + right: Some(Box::new(BinaryTreeNode { + value: 8, + left: Some(Box::new(BinaryTreeNode { + value: 9, + left: None, + right: Some(Box::new(BinaryTreeNode { + value: 10, left: None, right: None, - } - ) - ), - right: Some( - Box::new( - BinaryTreeNode { - value: 6, - left: Some( - Box::new( - BinaryTreeNode { - value: 7, - left: None, - right: Some( - Box::new( - BinaryTreeNode { - value: 8, - left: Some( - Box::new( - BinaryTreeNode { - value: 9, - left: None, - right: Some( - Box::new( - BinaryTreeNode { - value: 10, - left: None, - right: None - } - ) - ) - } - ) - ), - right: None - } - ) - ) - } - ) - ), - right: None, - } - ) - ) - } - ) - ) + })), + })), + right: None, + })), + })), + right: None, + })), + })), } } @@ -98,47 +58,39 @@ pub fn create_example_tree() -> TreeNode { children: Some(vec![ TreeNode { value: 3, - children: None + children: None, }, TreeNode { value: 4, - children: None - } - ]) + children: None, + }, + ]), }, TreeNode { value: 2, children: Some(vec![ TreeNode { value: 5, - children: None + children: None, }, TreeNode { value: 6, - children: Some(vec![ - TreeNode { - value: 7, - children: Some(vec![ - TreeNode { - value: 8, - children: Some(vec![ - TreeNode { - value: 9, - children: Some(vec![ - TreeNode { - value: 10, - children: None - } - ]) - } - ]) - } - ]) - } - ]) - } - ]) - } - ]) + children: Some(vec![TreeNode { + value: 7, + children: Some(vec![TreeNode { + value: 8, + children: Some(vec![TreeNode { + value: 9, + children: Some(vec![TreeNode { + value: 10, + children: None, + }]), + }]), + }]), + }]), + }, + ]), + }, + ]), } -} \ No newline at end of file +} diff --git a/src/leaves_iterators/ancestors_breadth_first/borrow.rs b/src/leaves_iterators/ancestors_breadth_first/borrow.rs new file mode 100644 index 0000000..5d880db --- /dev/null +++ b/src/leaves_iterators/ancestors_breadth_first/borrow.rs @@ -0,0 +1,116 @@ +use alloc::{collections::VecDeque, vec::Vec}; +use core::iter::Peekable; +use streaming_iterator::StreamingIterator; + +use crate::{ + bfs_iterators::borrow::{ + BorrowedBFSIteratorWithAncestors, BorrowedBinaryBFSIteratorWithAncestors, + }, + prelude::{AncestorsLeavesIterator, BinaryChildren, BorrowedBinaryTreeNode, BorrowedTreeNode}, +}; + +use super::{bfs_next, streaming_leaves}; + +use crate::bfs_iterators::TreeNodeVecDeque; + +pub struct BorrowedBFSLeavesIteratorWithAncestors<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ + is_root: bool, + item_stack: Vec, + tree_cache: TreeNodeVecDeque, + traversal_stack: Vec>, + iterator_queue: VecDeque>>, +} + +impl<'a, Node> BorrowedBFSLeavesIteratorWithAncestors<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ + pub(crate) fn new( + source: BorrowedBFSIteratorWithAncestors<'a, Node>, + ) -> BorrowedBFSLeavesIteratorWithAncestors<'a, Node> { + BorrowedBFSLeavesIteratorWithAncestors { + is_root: source.is_root, + item_stack: source.item_stack, + iterator_queue: source + .iterator_queue + .into_iter() + .map(|val| match val { + None => None, + Some(val) => Some(val.peekable()), + }) + .collect(), + traversal_stack: source.traversal_stack, + tree_cache: source.tree_cache, + } + } + + bfs_next!(get_value_and_children_iter); +} + +impl<'a, Node> AncestorsLeavesIterator for BorrowedBFSLeavesIteratorWithAncestors<'a, Node> where + Node: BorrowedTreeNode<'a> +{ +} + +impl<'a, Node> StreamingIterator for BorrowedBFSLeavesIteratorWithAncestors<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ + type Item = [Node::BorrowedValue]; + + streaming_leaves!(); +} + +pub struct BorrowedBinaryBFSLeavesIteratorWithAncestors<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ + is_root: bool, + item_stack: Vec, + tree_cache: TreeNodeVecDeque, + traversal_stack: Vec>, + iterator_queue: VecDeque>>>, +} + +impl<'a, Node> BorrowedBinaryBFSLeavesIteratorWithAncestors<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ + pub(crate) fn new( + source: BorrowedBinaryBFSIteratorWithAncestors<'a, Node>, + ) -> BorrowedBinaryBFSLeavesIteratorWithAncestors<'a, Node> { + BorrowedBinaryBFSLeavesIteratorWithAncestors { + is_root: source.is_root, + item_stack: source.item_stack, + iterator_queue: source + .iterator_queue + .into_iter() + .map(|val| match val { + None => None, + Some(val) => Some(val.peekable()), + }) + .collect(), + traversal_stack: source.traversal_stack, + tree_cache: source.tree_cache, + } + } + + bfs_next!(get_value_and_children_iter); +} + +impl<'a, Node> StreamingIterator for BorrowedBinaryBFSLeavesIteratorWithAncestors<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ + type Item = [Node::BorrowedValue]; + + streaming_leaves!(); +} + +impl<'a, Node> AncestorsLeavesIterator for BorrowedBinaryBFSLeavesIteratorWithAncestors<'a, Node> where + Node: BorrowedBinaryTreeNode<'a> +{ +} diff --git a/src/leaves_iterators/ancestors_breadth_first/mod.rs b/src/leaves_iterators/ancestors_breadth_first/mod.rs new file mode 100644 index 0000000..f1e2aab --- /dev/null +++ b/src/leaves_iterators/ancestors_breadth_first/mod.rs @@ -0,0 +1,233 @@ +pub(crate) mod borrow; +pub(crate) mod mut_borrow; +pub(crate) mod owned; + +macro_rules! bfs_next { + ($get_value_and_children: ident) => { + fn bfs_next(&mut self) -> bool { + if self.is_root { + self.is_root = false; + let first_iter = self + .iterator_queue + .get_mut(0) + .expect("root node to have a children collection on the stack"); + return first_iter.is_some() + && first_iter + .as_mut() + .expect("to be Some() after .is_some() call") + .peek() + .is_some(); + } + + loop { + match self.iterator_queue.get_mut(0) { + None => { + self.item_stack.clear(); + return false; + } + Some(iter) => { + if let Some(iter) = iter { + if let Some(next) = iter.next() { + if self.item_stack.len() == self.traversal_stack.len() + 2 { + self.pop_from_item_stack(); + } + let (value, children) = next.$get_value_and_children(); + self.item_stack.push(value); + let has_children; + let peekable_children = match children { + None => { + has_children = false; + None + } + Some(iter) => { + let mut peekable_children = iter.peekable(); + has_children = peekable_children.peek().is_some(); + Some(peekable_children) + } + }; + + self.iterator_queue.push_back(peekable_children); + return has_children; + } + } + + if self.item_stack.len() == self.traversal_stack.len() + 2 { + self.pop_from_item_stack(); + } + + let top_of_traversal_stack = if self.traversal_stack.len() == 0 { + &mut self.tree_cache + } else { + let stack_len = self.traversal_stack.len(); + self.traversal_stack.get_mut(stack_len - 1).unwrap() + }; + + match &mut top_of_traversal_stack.children { + Some(children) => children.push_front(None), + // used up all the value, so just pop it + None => { + while self.traversal_stack.len() > 0 + && (self + .traversal_stack + .get(self.traversal_stack.len() - 1) + .unwrap() + .children + .is_none() + || self + .traversal_stack + .get(self.traversal_stack.len() - 1) + .unwrap() + .children + .as_ref() + .unwrap() + .len() + == 1) + { + self.traversal_stack.pop(); + self.item_stack.pop(); + } + } + } + + self.advance_dfs(); + self.iterator_queue.pop_front(); + } + } + } + } + + fn advance_dfs(&mut self) { + let mut stack_len = self.traversal_stack.len(); + let starting_depth = self.item_stack.len(); + loop { + let tree_node = if stack_len == 0 { + &mut self.tree_cache + } else { + self.traversal_stack.get_mut(stack_len - 1).unwrap() + }; + + match tree_node.children.as_mut() { + None => break, + Some(children) => { + match children.pop_front() { + None => { + tree_node.children = None; + // just let the value get dropped + } + Some(child) => { + match child { + None => { + if children.len() != 0 { + children.push_back(None); + } else { + tree_node.children = None; + // let the child be dropped from memory + } + + if self.item_stack.len() > 1 { + let target = self + .traversal_stack + .get_mut(stack_len - 1) + .unwrap(); + target.value = self.item_stack.pop(); + } + + if self.traversal_stack.len() == 0 { + continue; + } + let popped = self.traversal_stack.pop().unwrap(); + stack_len -= 1; + + let parent = if stack_len < 1 { + &mut self.tree_cache + } else { + self.traversal_stack.get_mut(stack_len - 1).unwrap() + }; + + parent.children.as_mut().unwrap().push_back(Some(popped)); + } + Some(mut value) => { + self.item_stack + .push(core::mem::take(&mut value.value).unwrap()); + let has_children = !value.children.is_none(); + self.traversal_stack.push(value); + stack_len += 1; + if !has_children && self.item_stack.len() >= starting_depth + { + break; + } else { + continue; + } + } + } + } + } + } + } + } + } + + fn pop_from_item_stack(&mut self) { + if self.item_stack.len() == 1 { + return; + } + let tree_node = match self.item_stack.len() { + 0 | 1 => panic!("item stack len should never be 0 or 1 here!"), + 2 => &mut self.tree_cache, + _ => self + .traversal_stack + .get_mut(self.item_stack.len() - 3) + .unwrap(), + }; + + let children = match &mut tree_node.children { + None => { + tree_node.children = Some(VecDeque::new()); + tree_node.children.as_mut().unwrap() + } + Some(children) => children, + }; + + children.push_back(Some(TreeNodeVecDeque { + value: Some(self.item_stack.pop().unwrap()), + children: None, + })); + } + }; +} + +macro_rules! get_mut { + () => { + fn get_mut(&mut self) -> Option<&mut Self::Item> { + if self.item_stack.len() == 0 { + None + } else { + Some(&mut self.item_stack[..]) + } + } + }; +} + +macro_rules! streaming_leaves { + () => { + fn advance(&mut self) { + loop { + if !self.bfs_next() { + break; + } + } + } + + fn get(&self) -> Option<&Self::Item> { + if self.item_stack.len() == 0 { + None + } else { + Some(self.item_stack.as_slice()) + } + } + }; +} + +pub(crate) use bfs_next; +pub(crate) use get_mut; +pub(crate) use streaming_leaves; diff --git a/src/leaves_iterators/ancestors_breadth_first/mut_borrow.rs b/src/leaves_iterators/ancestors_breadth_first/mut_borrow.rs new file mode 100644 index 0000000..5adbe70 --- /dev/null +++ b/src/leaves_iterators/ancestors_breadth_first/mut_borrow.rs @@ -0,0 +1,134 @@ +use alloc::{collections::VecDeque, vec::Vec}; +use core::iter::Peekable; +use streaming_iterator::{StreamingIterator, StreamingIteratorMut}; + +use crate::{ + bfs_iterators::mut_borrow::{ + MutBorrowedBFSIteratorWithAncestors, MutBorrowedBinaryBFSIteratorWithAncestors, + }, + prelude::{ + AncestorsLeavesIteratorMut, BinaryChildren, MutBorrowedBinaryTreeNode, MutBorrowedTreeNode, + }, +}; + +use super::{bfs_next, get_mut, streaming_leaves}; + +use crate::bfs_iterators::TreeNodeVecDeque; + +pub struct MutBorrowedBFSLeavesIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ + is_root: bool, + item_stack: Vec, + tree_cache: TreeNodeVecDeque, + traversal_stack: Vec>, + iterator_queue: VecDeque>>, +} + +impl<'a, Node> MutBorrowedBFSLeavesIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ + pub(crate) fn new( + source: MutBorrowedBFSIteratorWithAncestors<'a, Node>, + ) -> MutBorrowedBFSLeavesIteratorWithAncestors<'a, Node> { + MutBorrowedBFSLeavesIteratorWithAncestors { + is_root: source.is_root, + item_stack: source.item_stack, + iterator_queue: source + .iterator_queue + .into_iter() + .map(|val| match val { + None => None, + Some(val) => Some(val.peekable()), + }) + .collect(), + traversal_stack: source.traversal_stack, + tree_cache: source.tree_cache, + } + } + + bfs_next!(get_value_and_children_iter_mut); +} + +impl<'a, Node> AncestorsLeavesIteratorMut for MutBorrowedBFSLeavesIteratorWithAncestors<'a, Node> where + Node: MutBorrowedTreeNode<'a> +{ +} + +impl<'a, Node> StreamingIterator for MutBorrowedBFSLeavesIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ + type Item = [Node::MutBorrowedValue]; + + streaming_leaves!(); +} + +impl<'a, Node> StreamingIteratorMut for MutBorrowedBFSLeavesIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ + get_mut!(); +} + +pub struct MutBorrowedBinaryBFSLeavesIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ + is_root: bool, + item_stack: Vec, + tree_cache: TreeNodeVecDeque, + traversal_stack: Vec>, + iterator_queue: VecDeque>>>, +} + +impl<'a, Node> MutBorrowedBinaryBFSLeavesIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ + pub(crate) fn new( + source: MutBorrowedBinaryBFSIteratorWithAncestors<'a, Node>, + ) -> MutBorrowedBinaryBFSLeavesIteratorWithAncestors<'a, Node> { + MutBorrowedBinaryBFSLeavesIteratorWithAncestors { + is_root: source.is_root, + item_stack: source.item_stack, + iterator_queue: source + .iterator_queue + .into_iter() + .map(|val| match val { + None => None, + Some(val) => Some(val.peekable()), + }) + .collect(), + traversal_stack: source.traversal_stack, + tree_cache: source.tree_cache, + } + } + + bfs_next!(get_value_and_children_iter_mut); +} + +impl<'a, Node> StreamingIterator for MutBorrowedBinaryBFSLeavesIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ + type Item = [Node::MutBorrowedValue]; + + streaming_leaves!(); +} + +impl<'a, Node> StreamingIteratorMut for MutBorrowedBinaryBFSLeavesIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ + get_mut!(); +} + +impl<'a, Node> AncestorsLeavesIteratorMut + for MutBorrowedBinaryBFSLeavesIteratorWithAncestors<'a, Node> +where + Node: MutBorrowedBinaryTreeNode<'a>, +{ +} diff --git a/src/leaves_iterators/ancestors_breadth_first/owned.rs b/src/leaves_iterators/ancestors_breadth_first/owned.rs new file mode 100644 index 0000000..97ad809 --- /dev/null +++ b/src/leaves_iterators/ancestors_breadth_first/owned.rs @@ -0,0 +1,128 @@ +use alloc::{collections::VecDeque, vec::Vec}; +use core::iter::Peekable; +use streaming_iterator::{StreamingIterator, StreamingIteratorMut}; + +use crate::{ + bfs_iterators::owned::{OwnedBFSIteratorWithAncestors, OwnedBinaryBFSIteratorWithAncestors}, + prelude::{AncestorsLeavesIteratorMut, BinaryChildren, OwnedBinaryTreeNode, OwnedTreeNode}, +}; + +use super::{bfs_next, get_mut, streaming_leaves}; + +use crate::bfs_iterators::TreeNodeVecDeque; + +pub struct OwnedBFSLeavesIteratorWithAncestors +where + Node: OwnedTreeNode, +{ + is_root: bool, + item_stack: Vec, + tree_cache: TreeNodeVecDeque, + traversal_stack: Vec>, + iterator_queue: VecDeque>>, +} + +impl OwnedBFSLeavesIteratorWithAncestors +where + Node: OwnedTreeNode, +{ + pub(crate) fn new( + source: OwnedBFSIteratorWithAncestors, + ) -> OwnedBFSLeavesIteratorWithAncestors { + OwnedBFSLeavesIteratorWithAncestors { + is_root: source.is_root, + item_stack: source.item_stack, + iterator_queue: source + .iterator_queue + .into_iter() + .map(|val| match val { + None => None, + Some(val) => Some(val.peekable()), + }) + .collect(), + traversal_stack: source.traversal_stack, + tree_cache: source.tree_cache, + } + } + + bfs_next!(get_value_and_children); +} + +impl AncestorsLeavesIteratorMut for OwnedBFSLeavesIteratorWithAncestors where + Node: OwnedTreeNode +{ +} + +impl StreamingIterator for OwnedBFSLeavesIteratorWithAncestors +where + Node: OwnedTreeNode, +{ + type Item = [Node::OwnedValue]; + + streaming_leaves!(); +} + +impl StreamingIteratorMut for OwnedBFSLeavesIteratorWithAncestors +where + Node: OwnedTreeNode, +{ + get_mut!(); +} + +pub struct OwnedBinaryBFSLeavesIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, +{ + is_root: bool, + item_stack: Vec, + tree_cache: TreeNodeVecDeque, + traversal_stack: Vec>, + iterator_queue: VecDeque>>>, +} + +impl OwnedBinaryBFSLeavesIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, +{ + pub(crate) fn new( + source: OwnedBinaryBFSIteratorWithAncestors, + ) -> OwnedBinaryBFSLeavesIteratorWithAncestors { + OwnedBinaryBFSLeavesIteratorWithAncestors { + is_root: source.is_root, + item_stack: source.item_stack, + iterator_queue: source + .iterator_queue + .into_iter() + .map(|val| match val { + None => None, + Some(val) => Some(val.peekable()), + }) + .collect(), + traversal_stack: source.traversal_stack, + tree_cache: source.tree_cache, + } + } + + bfs_next!(get_value_and_children); +} + +impl StreamingIterator for OwnedBinaryBFSLeavesIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, +{ + type Item = [Node::OwnedValue]; + + streaming_leaves!(); +} + +impl StreamingIteratorMut for OwnedBinaryBFSLeavesIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, +{ + get_mut!(); +} + +impl AncestorsLeavesIteratorMut for OwnedBinaryBFSLeavesIteratorWithAncestors where + Node: OwnedBinaryTreeNode +{ +} diff --git a/src/leaves_iterators/ancestors_depth_first/borrow.rs b/src/leaves_iterators/ancestors_depth_first/borrow.rs new file mode 100644 index 0000000..26a8711 --- /dev/null +++ b/src/leaves_iterators/ancestors_depth_first/borrow.rs @@ -0,0 +1,65 @@ +use crate::prelude::{ + AncestorsLeavesIterator, BinaryChildren, BorrowedBinaryTreeNode, BorrowedTreeNode, +}; +use alloc::vec::Vec; +use streaming_iterator::StreamingIterator; + +use super::streaming_leaves; + +pub struct BorrowedDFSLeavesPostorderIteratorWithAncestors<'a, Node, Iter> +where + Node: BorrowedTreeNode<'a>, + Iter: Iterator, +{ + pub(crate) root: Option<&'a Node>, + pub(crate) item_stack: Vec, + pub(crate) old_traversal_stack: Vec, + pub(crate) new_traversal_stack: Vec, +} + +impl<'a, Node, Iter> StreamingIterator + for BorrowedDFSLeavesPostorderIteratorWithAncestors<'a, Node, Iter> +where + Node: BorrowedTreeNode<'a>, + Iter: Iterator, +{ + type Item = [Node::BorrowedValue]; + streaming_leaves!(get_value_and_children_iter); +} + +impl<'a, Node, Iter> AncestorsLeavesIterator + for BorrowedDFSLeavesPostorderIteratorWithAncestors<'a, Node, Iter> +where + Node: BorrowedTreeNode<'a>, + Iter: Iterator, +{ +} + +pub struct BorrowedBinaryDFSLeavesPostorderIteratorWithAncestors<'a, Node, Iter> +where + Node: BorrowedBinaryTreeNode<'a>, + Iter: Iterator, +{ + pub(crate) root: Option<&'a Node>, + pub(crate) item_stack: Vec, + pub(crate) old_traversal_stack: Vec, + pub(crate) new_traversal_stack: Vec>, +} + +impl<'a, Node, Iter> StreamingIterator + for BorrowedBinaryDFSLeavesPostorderIteratorWithAncestors<'a, Node, Iter> +where + Node: BorrowedBinaryTreeNode<'a>, + Iter: Iterator, +{ + type Item = [Node::BorrowedValue]; + streaming_leaves!(get_value_and_children_iter); +} + +impl<'a, Node, Iter> AncestorsLeavesIterator + for BorrowedBinaryDFSLeavesPostorderIteratorWithAncestors<'a, Node, Iter> +where + Node: BorrowedBinaryTreeNode<'a>, + Iter: Iterator, +{ +} diff --git a/src/leaves_iterators/ancestors_depth_first/mod.rs b/src/leaves_iterators/ancestors_depth_first/mod.rs new file mode 100644 index 0000000..e6586d3 --- /dev/null +++ b/src/leaves_iterators/ancestors_depth_first/mod.rs @@ -0,0 +1,135 @@ +pub(crate) mod borrow; +pub(crate) mod mut_borrow; +pub(crate) mod owned; + +macro_rules! streaming_leaves { + ($get_value_and_children: ident) => { + fn advance(&mut self) { + loop { + match core::mem::take(&mut self.root) { + Some(next) => { + let (value, children) = next.$get_value_and_children(); + match children { + None => return, + Some(children) => { + self.new_traversal_stack.push(children); + self.item_stack.push(value); + } + } + } + None => { + let mut pushed_another_iterator = false; + loop { + let total_stack_len = + self.old_traversal_stack.len() + self.new_traversal_stack.len(); + if total_stack_len < 1 { + self.item_stack.pop(); + return; + } + let new_stack_len = self.new_traversal_stack.len(); + if new_stack_len > 0 { + match self.new_traversal_stack.get_mut(new_stack_len - 1) { + None => { + self.item_stack.pop(); + } + Some(next_iter) => match next_iter.next() { + None => { + if self.item_stack.len() > total_stack_len { + self.item_stack.pop(); + } + self.new_traversal_stack.pop(); + if pushed_another_iterator { + return; + } + } + Some(node) => { + let (value, children) = node.$get_value_and_children(); + match children { + None => { + if !pushed_another_iterator { + self.item_stack.pop(); + } + self.item_stack.push(value); + return; + } + Some(children) => { + if self.item_stack.len() > total_stack_len { + self.item_stack.pop(); + } + self.new_traversal_stack.push(children); + self.item_stack.push(value); + pushed_another_iterator = true; + } + } + } + }, + } + continue; + } + let old_traversal_stack_len = self.old_traversal_stack.len(); + match self + .old_traversal_stack + .get_mut(old_traversal_stack_len - 1) + { + None => { + self.item_stack.pop(); + } + Some(next_iter) => match next_iter.next() { + None => { + if self.item_stack.len() > total_stack_len { + self.item_stack.pop(); + } + self.old_traversal_stack.pop(); + } + Some(node) => { + let (value, children) = node.$get_value_and_children(); + match children { + None => { + if !pushed_another_iterator { + self.item_stack.pop(); + } + self.item_stack.push(value); + return; + } + Some(children) => { + if self.item_stack.len() > total_stack_len { + self.item_stack.pop(); + } + self.new_traversal_stack.push(children); + self.item_stack.push(value); + pushed_another_iterator = true; + } + } + } + }, + } + } + } + } + } + } + + fn get(&self) -> Option<&Self::Item> { + if self.item_stack.len() > 0 { + Some(&self.item_stack.as_slice()) + } else { + None + } + } + }; +} + +macro_rules! get_mut { + () => { + fn get_mut(&mut self) -> Option<&mut Self::Item> { + if self.item_stack.len() == 0 { + None + } else { + Some(&mut self.item_stack[..]) + } + } + }; +} + +pub(crate) use get_mut; +pub(crate) use streaming_leaves; diff --git a/src/leaves_iterators/ancestors_depth_first/mut_borrow.rs b/src/leaves_iterators/ancestors_depth_first/mut_borrow.rs new file mode 100644 index 0000000..00f3ad7 --- /dev/null +++ b/src/leaves_iterators/ancestors_depth_first/mut_borrow.rs @@ -0,0 +1,83 @@ +use crate::prelude::{ + AncestorsLeavesIteratorMut, BinaryChildren, MutBorrowedBinaryTreeNode, MutBorrowedTreeNode, +}; +use alloc::vec::Vec; +use streaming_iterator::{StreamingIterator, StreamingIteratorMut}; + +use super::{get_mut, streaming_leaves}; + +pub struct MutBorrowedDFSLeavesPostorderIteratorWithAncestors<'a, Node, Iter> +where + Node: MutBorrowedTreeNode<'a>, + Iter: Iterator, +{ + pub(crate) root: Option<&'a mut Node>, + pub(crate) item_stack: Vec, + pub(crate) old_traversal_stack: Vec, + pub(crate) new_traversal_stack: Vec, +} + +impl<'a, Node, Iter> StreamingIterator + for MutBorrowedDFSLeavesPostorderIteratorWithAncestors<'a, Node, Iter> +where + Node: MutBorrowedTreeNode<'a>, + Iter: Iterator, +{ + type Item = [Node::MutBorrowedValue]; + streaming_leaves!(get_value_and_children_iter_mut); +} + +impl<'a, Node, Iter> StreamingIteratorMut + for MutBorrowedDFSLeavesPostorderIteratorWithAncestors<'a, Node, Iter> +where + Node: MutBorrowedTreeNode<'a>, + Iter: Iterator, +{ + get_mut!(); +} + +impl<'a, Node, Iter> AncestorsLeavesIteratorMut + for MutBorrowedDFSLeavesPostorderIteratorWithAncestors<'a, Node, Iter> +where + Node: MutBorrowedTreeNode<'a>, + Iter: Iterator, +{ +} + +pub struct MutBorrowedBinaryDFSLeavesPostorderIteratorWithAncestors<'a, Node, Iter> +where + Node: MutBorrowedBinaryTreeNode<'a>, + Iter: Iterator, +{ + pub(crate) root: Option<&'a mut Node>, + pub(crate) item_stack: Vec, + pub(crate) old_traversal_stack: Vec, + pub(crate) new_traversal_stack: Vec>, +} + +impl<'a, Node, Iter> StreamingIterator + for MutBorrowedBinaryDFSLeavesPostorderIteratorWithAncestors<'a, Node, Iter> +where + Node: MutBorrowedBinaryTreeNode<'a>, + Iter: Iterator, +{ + type Item = [Node::MutBorrowedValue]; + streaming_leaves!(get_value_and_children_iter_mut); +} + +impl<'a, Node, Iter> StreamingIteratorMut + for MutBorrowedBinaryDFSLeavesPostorderIteratorWithAncestors<'a, Node, Iter> +where + Node: MutBorrowedBinaryTreeNode<'a>, + Iter: Iterator, +{ + get_mut!(); +} + +impl<'a, Node, Iter> AncestorsLeavesIteratorMut + for MutBorrowedBinaryDFSLeavesPostorderIteratorWithAncestors<'a, Node, Iter> +where + Node: MutBorrowedBinaryTreeNode<'a>, + Iter: Iterator, +{ +} diff --git a/src/leaves_iterators/ancestors_depth_first/owned.rs b/src/leaves_iterators/ancestors_depth_first/owned.rs new file mode 100644 index 0000000..eeec807 --- /dev/null +++ b/src/leaves_iterators/ancestors_depth_first/owned.rs @@ -0,0 +1,81 @@ +use crate::prelude::{ + AncestorsLeavesIteratorMut, BinaryChildren, OwnedBinaryTreeNode, OwnedTreeNode, +}; +use alloc::vec::Vec; +use streaming_iterator::{StreamingIterator, StreamingIteratorMut}; + +use super::{get_mut, streaming_leaves}; + +pub struct OwnedDFSLeavesPostorderIteratorWithAncestors +where + Node: OwnedTreeNode, + Iter: Iterator, +{ + pub(crate) root: Option, + pub(crate) item_stack: Vec, + pub(crate) old_traversal_stack: Vec, + pub(crate) new_traversal_stack: Vec, +} + +impl StreamingIterator for OwnedDFSLeavesPostorderIteratorWithAncestors +where + Node: OwnedTreeNode, + Iter: Iterator, +{ + type Item = [Node::OwnedValue]; + streaming_leaves!(get_value_and_children); +} + +impl StreamingIteratorMut for OwnedDFSLeavesPostorderIteratorWithAncestors +where + Node: OwnedTreeNode, + Iter: Iterator, +{ + get_mut!(); +} + +impl AncestorsLeavesIteratorMut + for OwnedDFSLeavesPostorderIteratorWithAncestors +where + Node: OwnedTreeNode, + Iter: Iterator, +{ +} + +pub struct OwnedBinaryDFSLeavesPostorderIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, + Iter: Iterator, +{ + pub(crate) root: Option, + pub(crate) item_stack: Vec, + pub(crate) old_traversal_stack: Vec, + pub(crate) new_traversal_stack: Vec>, +} + +impl StreamingIterator + for OwnedBinaryDFSLeavesPostorderIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, + Iter: Iterator, +{ + type Item = [Node::OwnedValue]; + streaming_leaves!(get_value_and_children); +} + +impl StreamingIteratorMut + for OwnedBinaryDFSLeavesPostorderIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, + Iter: Iterator, +{ + get_mut!(); +} + +impl AncestorsLeavesIteratorMut + for OwnedBinaryDFSLeavesPostorderIteratorWithAncestors +where + Node: OwnedBinaryTreeNode, + Iter: Iterator, +{ +} diff --git a/src/leaves_iterators/breadth_first/borrow.rs b/src/leaves_iterators/breadth_first/borrow.rs index ee924e7..5d9dab3 100644 --- a/src/leaves_iterators/breadth_first/borrow.rs +++ b/src/leaves_iterators/breadth_first/borrow.rs @@ -1,61 +1,62 @@ use alloc::collections::VecDeque; -use crate::prelude::{ - BorrowedTreeNode, - BinaryChildren, - BorrowedBinaryTreeNode, LeavesIterator -}; +use crate::prelude::{BinaryChildren, BorrowedBinaryTreeNode, BorrowedTreeNode, LeavesIterator}; use core::iter::Peekable; -use super::{ - bfs_next, - next -}; +use super::{bfs_next, next}; pub struct BorrowedLeavesIterator<'a, Node> - where Node: BorrowedTreeNode<'a> { - - pub (crate) root: Option<&'a Node>, - pub (crate) old_traversal_queue: VecDeque, - pub (crate) new_traversal_queue: VecDeque>, +where + Node: BorrowedTreeNode<'a>, +{ + pub(crate) root: Option<&'a Node>, + pub(crate) old_traversal_queue: VecDeque, + pub(crate) new_traversal_queue: VecDeque>, } impl<'a, Node> LeavesIterator for BorrowedLeavesIterator<'a, Node> where Node: BorrowedTreeNode<'a> {} -impl<'a, Node> BorrowedLeavesIterator<'a, Node> - where Node: BorrowedTreeNode<'a>, { - +impl<'a, Node> BorrowedLeavesIterator<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ bfs_next!(get_value_and_children_iter, Node::BorrowedValue); } -impl<'a, Node> Iterator for BorrowedLeavesIterator<'a, Node> - where Node: BorrowedTreeNode<'a> { - +impl<'a, Node> Iterator for BorrowedLeavesIterator<'a, Node> +where + Node: BorrowedTreeNode<'a>, +{ type Item = Node::BorrowedValue; next!(); } pub struct BorrowedBinaryLeavesIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - - pub (crate) root: Option<&'a Node>, - pub (crate) old_traversal_queue: VecDeque>, - pub (crate) new_traversal_queue: VecDeque>>, +where + Node: BorrowedBinaryTreeNode<'a>, +{ + pub(crate) root: Option<&'a Node>, + pub(crate) old_traversal_queue: VecDeque>, + pub(crate) new_traversal_queue: VecDeque>>, } -impl<'a, Node> BorrowedBinaryLeavesIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +impl<'a, Node> BorrowedBinaryLeavesIterator<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ bfs_next!(get_value_and_children_iter, Node::BorrowedValue); } -impl<'a, Node> Iterator for BorrowedBinaryLeavesIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> { - +impl<'a, Node> Iterator for BorrowedBinaryLeavesIterator<'a, Node> +where + Node: BorrowedBinaryTreeNode<'a>, +{ type Item = Node::BorrowedValue; next!(); } -impl<'a, Node> LeavesIterator for BorrowedBinaryLeavesIterator<'a, Node> - where Node: BorrowedBinaryTreeNode<'a> {} \ No newline at end of file +impl<'a, Node> LeavesIterator for BorrowedBinaryLeavesIterator<'a, Node> where + Node: BorrowedBinaryTreeNode<'a> +{ +} diff --git a/src/leaves_iterators/breadth_first/mod.rs b/src/leaves_iterators/breadth_first/mod.rs index 4d240cc..9b5959d 100644 --- a/src/leaves_iterators/breadth_first/mod.rs +++ b/src/leaves_iterators/breadth_first/mod.rs @@ -1,6 +1,6 @@ -pub mod owned; -pub mod mut_borrow; pub mod borrow; +pub mod mut_borrow; +pub mod owned; macro_rules! bfs_next { ($get_value_and_children: ident, $value_type: ty) => { @@ -8,10 +8,12 @@ macro_rules! bfs_next { match core::mem::take(&mut self.root) { Some(root) => { let (value, children) = root.$get_value_and_children(); - + let has_children; match children { - None => { has_children = false; } + None => { + has_children = false; + } Some(children) => { let mut peekable = children.peekable(); has_children = peekable.peek().is_some(); @@ -20,65 +22,63 @@ macro_rules! bfs_next { } return Some((has_children, value)); } - None => { - loop { - let old_next_queue_opt = self.old_traversal_queue.get_mut(0); - match old_next_queue_opt { - None => { - let new_next_queue_opt = self.new_traversal_queue.get_mut(0); - match new_next_queue_opt { - None => return None, - Some(next_queue) => { - match next_queue.next() { - None => { - self.new_traversal_queue.pop_front(); - continue; - } - Some(next) => { - let (value, children) = next.$get_value_and_children(); - - let has_children; - match children { - None => { has_children = false; } - Some(children) => { - let mut peekable = children.peekable(); - has_children = peekable.peek().is_some(); - self.new_traversal_queue.push_back(peekable); - } - } - - return Some((has_children, value)); - } - } - } - } - }, - Some(next_queue) => { - match next_queue.next() { + None => loop { + let old_next_queue_opt = self.old_traversal_queue.get_mut(0); + match old_next_queue_opt { + None => { + let new_next_queue_opt = self.new_traversal_queue.get_mut(0); + match new_next_queue_opt { + None => return None, + Some(next_queue) => match next_queue.next() { None => { - self.old_traversal_queue.pop_front(); + self.new_traversal_queue.pop_front(); continue; } Some(next) => { let (value, children) = next.$get_value_and_children(); - + let has_children; match children { - None => { has_children = false; } - Some(children) => { + None => { + has_children = false; + } + Some(children) => { let mut peekable = children.peekable(); has_children = peekable.peek().is_some(); self.new_traversal_queue.push_back(peekable); } } - + return Some((has_children, value)); } - } + }, } } + Some(next_queue) => match next_queue.next() { + None => { + self.old_traversal_queue.pop_front(); + continue; + } + Some(next) => { + let (value, children) = next.$get_value_and_children(); + + let has_children; + match children { + None => { + has_children = false; + } + Some(children) => { + let mut peekable = children.peekable(); + has_children = peekable.peek().is_some(); + self.new_traversal_queue.push_back(peekable); + } + } + + return Some((has_children, value)); + } + }, } - } + }, } } }; @@ -92,7 +92,9 @@ macro_rules! next { match value { None => return None, Some(value) => { - if value.0 { continue; } + if value.0 { + continue; + } return Some(value.1); } } @@ -101,5 +103,5 @@ macro_rules! next { }; } -pub (crate) use bfs_next; -pub (crate) use next; \ No newline at end of file +pub(crate) use bfs_next; +pub(crate) use next; diff --git a/src/leaves_iterators/breadth_first/mut_borrow.rs b/src/leaves_iterators/breadth_first/mut_borrow.rs index df41186..2720a1e 100644 --- a/src/leaves_iterators/breadth_first/mut_borrow.rs +++ b/src/leaves_iterators/breadth_first/mut_borrow.rs @@ -1,66 +1,72 @@ use alloc::collections::VecDeque; use crate::prelude::{ - MutBorrowedTreeNode, - BinaryChildren, - MutBorrowedBinaryTreeNode, LeavesIterator + BinaryChildren, LeavesIterator, MutBorrowedBinaryTreeNode, MutBorrowedTreeNode, }; use core::iter::Peekable; -use super::{ - bfs_next, - next -}; +use super::{bfs_next, next}; pub struct MutBorrowedLeavesIterator<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - - pub (crate) root: Option<&'a mut Node>, - pub (crate) old_traversal_queue: VecDeque, - pub (crate) new_traversal_queue: VecDeque>, +where + Node: MutBorrowedTreeNode<'a>, +{ + pub(crate) root: Option<&'a mut Node>, + pub(crate) old_traversal_queue: VecDeque, + pub(crate) new_traversal_queue: VecDeque>, } -impl<'a, Node> MutBorrowedLeavesIterator<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - +impl<'a, Node> MutBorrowedLeavesIterator<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ bfs_next!(get_value_and_children_iter_mut, Node::MutBorrowedValue); } -impl<'a, Node> Iterator for MutBorrowedLeavesIterator<'a, Node> - where Node: MutBorrowedTreeNode<'a> { - +impl<'a, Node> Iterator for MutBorrowedLeavesIterator<'a, Node> +where + Node: MutBorrowedTreeNode<'a>, +{ type Item = Node::MutBorrowedValue; next!(); } -impl<'a, Node> LeavesIterator for MutBorrowedLeavesIterator<'a, Node> - where Node: MutBorrowedTreeNode<'a> {} +impl<'a, Node> LeavesIterator for MutBorrowedLeavesIterator<'a, Node> where + Node: MutBorrowedTreeNode<'a> +{ +} pub struct MutBorrowedBinaryLeavesIterator<'a, Node, Iter> - where Node: MutBorrowedBinaryTreeNode<'a>, - Iter: Iterator { - - pub (crate) root: Option<&'a mut Node>, - pub (crate) old_traversal_queue: VecDeque, - pub (crate) new_traversal_queue: VecDeque>>, +where + Node: MutBorrowedBinaryTreeNode<'a>, + Iter: Iterator, +{ + pub(crate) root: Option<&'a mut Node>, + pub(crate) old_traversal_queue: VecDeque, + pub(crate) new_traversal_queue: VecDeque>>, } -impl<'a, Node, Iter> MutBorrowedBinaryLeavesIterator<'a, Node, Iter> - where Node: MutBorrowedBinaryTreeNode<'a>, - Iter: Iterator { - +impl<'a, Node, Iter> MutBorrowedBinaryLeavesIterator<'a, Node, Iter> +where + Node: MutBorrowedBinaryTreeNode<'a>, + Iter: Iterator, +{ bfs_next!(get_value_and_children_iter_mut, Node::MutBorrowedValue); } -impl<'a, Node, Iter> Iterator for MutBorrowedBinaryLeavesIterator<'a, Node, Iter> - where Node: MutBorrowedBinaryTreeNode<'a>, - Iter: Iterator { - +impl<'a, Node, Iter> Iterator for MutBorrowedBinaryLeavesIterator<'a, Node, Iter> +where + Node: MutBorrowedBinaryTreeNode<'a>, + Iter: Iterator, +{ type Item = Node::MutBorrowedValue; next!(); } -impl<'a, Node, Iter> LeavesIterator for MutBorrowedBinaryLeavesIterator<'a, Node, Iter> - where Node: MutBorrowedBinaryTreeNode<'a>, - Iter: Iterator {} \ No newline at end of file +impl<'a, Node, Iter> LeavesIterator for MutBorrowedBinaryLeavesIterator<'a, Node, Iter> +where + Node: MutBorrowedBinaryTreeNode<'a>, + Iter: Iterator, +{ +} diff --git a/src/leaves_iterators/breadth_first/owned.rs b/src/leaves_iterators/breadth_first/owned.rs index 4792239..2236acd 100644 --- a/src/leaves_iterators/breadth_first/owned.rs +++ b/src/leaves_iterators/breadth_first/owned.rs @@ -1,70 +1,75 @@ use alloc::collections::VecDeque; -use crate::prelude::{ - OwnedTreeNode, - BinaryChildren, - OwnedBinaryTreeNode, LeavesIterator -}; +use crate::prelude::{BinaryChildren, LeavesIterator, OwnedBinaryTreeNode, OwnedTreeNode}; use core::iter::Peekable; -use super::{ - bfs_next, - next -}; +use super::{bfs_next, next}; pub struct OwnedLeavesIterator - where Node: OwnedTreeNode, - Iter: Iterator { - - pub (crate) root: Option, - pub (crate) old_traversal_queue: VecDeque, - pub (crate) new_traversal_queue: VecDeque>, +where + Node: OwnedTreeNode, + Iter: Iterator, +{ + pub(crate) root: Option, + pub(crate) old_traversal_queue: VecDeque, + pub(crate) new_traversal_queue: VecDeque>, } -impl<'a, Node, Iter> OwnedLeavesIterator - where Node: OwnedTreeNode, - Iter: Iterator { - +impl<'a, Node, Iter> OwnedLeavesIterator +where + Node: OwnedTreeNode, + Iter: Iterator, +{ bfs_next!(get_value_and_children, Node::OwnedValue); } -impl Iterator for OwnedLeavesIterator - where Node: OwnedTreeNode, - Iter: Iterator { - +impl Iterator for OwnedLeavesIterator +where + Node: OwnedTreeNode, + Iter: Iterator, +{ type Item = Node::OwnedValue; next!(); } -impl LeavesIterator for OwnedLeavesIterator - where Node: OwnedTreeNode, - Iter: Iterator {} +impl LeavesIterator for OwnedLeavesIterator +where + Node: OwnedTreeNode, + Iter: Iterator, +{ +} pub struct OwnedBinaryLeavesIterator - where Node: OwnedBinaryTreeNode, - Iter: Iterator { - - pub (crate) root: Option, - pub (crate) old_traversal_queue: VecDeque, - pub (crate) new_traversal_queue: VecDeque>>, +where + Node: OwnedBinaryTreeNode, + Iter: Iterator, +{ + pub(crate) root: Option, + pub(crate) old_traversal_queue: VecDeque, + pub(crate) new_traversal_queue: VecDeque>>, } -impl OwnedBinaryLeavesIterator - where Node: OwnedBinaryTreeNode, - Iter: Iterator { - +impl OwnedBinaryLeavesIterator +where + Node: OwnedBinaryTreeNode, + Iter: Iterator, +{ bfs_next!(get_value_and_children, Node::OwnedValue); } -impl<'a, Node, Iter> Iterator for OwnedBinaryLeavesIterator - where Node: OwnedBinaryTreeNode, - Iter: Iterator { - +impl<'a, Node, Iter> Iterator for OwnedBinaryLeavesIterator +where + Node: OwnedBinaryTreeNode, + Iter: Iterator, +{ type Item = Node::OwnedValue; next!(); } -impl LeavesIterator for OwnedBinaryLeavesIterator - where Node: OwnedBinaryTreeNode, - Iter: Iterator {} \ No newline at end of file +impl LeavesIterator for OwnedBinaryLeavesIterator +where + Node: OwnedBinaryTreeNode, + Iter: Iterator, +{ +} diff --git a/src/leaves_iterators/depth_first/borrow.rs b/src/leaves_iterators/depth_first/borrow.rs index a313d3e..2ec470c 100644 --- a/src/leaves_iterators/depth_first/borrow.rs +++ b/src/leaves_iterators/depth_first/borrow.rs @@ -1,54 +1,60 @@ +use crate::prelude::{BinaryChildren, BorrowedBinaryTreeNode, BorrowedTreeNode, LeavesIterator}; use alloc::vec::Vec; -use crate::prelude::{ - BorrowedTreeNode, - BinaryChildren, - BorrowedBinaryTreeNode, LeavesIterator -}; use super::dfs_postorder_leaves_next; pub struct BorrowedLeavesIterator<'a, Node, Iter> - where Node: BorrowedTreeNode<'a>, - Iter: Iterator { - - pub (crate) root: Option<&'a Node>, - pub (crate) item_stack: Vec, - pub (crate) traversal_stack_bottom: Vec, - pub (crate) traversal_stack_top: Vec +where + Node: BorrowedTreeNode<'a>, + Iter: Iterator, +{ + pub(crate) root: Option<&'a Node>, + pub(crate) item_stack: Vec, + pub(crate) traversal_stack_bottom: Vec, + pub(crate) traversal_stack_top: Vec, } -impl<'a, Node, Iter> Iterator for BorrowedLeavesIterator<'a, Node, Iter> - where Node: BorrowedTreeNode<'a>, - Iter: Iterator { - +impl<'a, Node, Iter> Iterator for BorrowedLeavesIterator<'a, Node, Iter> +where + Node: BorrowedTreeNode<'a>, + Iter: Iterator, +{ type Item = Node::BorrowedValue; - + dfs_postorder_leaves_next!(get_value_and_children_iter); } impl<'a, Node, Iter> LeavesIterator for BorrowedLeavesIterator<'a, Node, Iter> - where Node: BorrowedTreeNode<'a>, - Iter: Iterator {} +where + Node: BorrowedTreeNode<'a>, + Iter: Iterator, +{ +} pub struct BorrowedBinaryLeavesIterator<'a, Node, Iter> - where Node: BorrowedBinaryTreeNode<'a>, - Iter: Iterator { - - pub (crate) root: Option<&'a Node>, - pub (crate) item_stack: Vec, - pub (crate) traversal_stack_bottom: Vec, - pub (crate) traversal_stack_top: Vec> +where + Node: BorrowedBinaryTreeNode<'a>, + Iter: Iterator, +{ + pub(crate) root: Option<&'a Node>, + pub(crate) item_stack: Vec, + pub(crate) traversal_stack_bottom: Vec, + pub(crate) traversal_stack_top: Vec>, } -impl<'a, Node, Iter> LeavesIterator for BorrowedBinaryLeavesIterator<'a, Node, Iter> - where Node: BorrowedBinaryTreeNode<'a>, - Iter: Iterator {} +impl<'a, Node, Iter> LeavesIterator for BorrowedBinaryLeavesIterator<'a, Node, Iter> +where + Node: BorrowedBinaryTreeNode<'a>, + Iter: Iterator, +{ +} -impl<'a, Node, Iter> Iterator for BorrowedBinaryLeavesIterator<'a, Node, Iter> - where Node: BorrowedBinaryTreeNode<'a>, - Iter: Iterator { - +impl<'a, Node, Iter> Iterator for BorrowedBinaryLeavesIterator<'a, Node, Iter> +where + Node: BorrowedBinaryTreeNode<'a>, + Iter: Iterator, +{ type Item = Node::BorrowedValue; dfs_postorder_leaves_next!(get_value_and_children_iter); -} \ No newline at end of file +} diff --git a/src/leaves_iterators/depth_first/mod.rs b/src/leaves_iterators/depth_first/mod.rs index 36c73be..d1d79fe 100644 --- a/src/leaves_iterators/depth_first/mod.rs +++ b/src/leaves_iterators/depth_first/mod.rs @@ -1,6 +1,6 @@ -pub mod owned; -pub mod mut_borrow; pub mod borrow; +pub mod mut_borrow; +pub mod owned; macro_rules! dfs_postorder_leaves_next { ($get_value_and_children: ident) => { @@ -10,7 +10,9 @@ macro_rules! dfs_postorder_leaves_next { Some(next) => { let (value, children) = next.$get_value_and_children(); match children { - None => { return Some(value); } + None => { + return Some(value); + } Some(children) => { self.traversal_stack_top.push(children); self.item_stack.push(value); @@ -18,57 +20,66 @@ macro_rules! dfs_postorder_leaves_next { } } None => { - // keep track of if the children iterator was just added. + // keep track of if the children iterator was just added. // In some cases this becomes important. let mut just_added = false; loop { - let total_stack_len = self.traversal_stack_bottom.len() + self.traversal_stack_top.len(); - if total_stack_len < 1 { return None; } + let total_stack_len = + self.traversal_stack_bottom.len() + self.traversal_stack_top.len(); + if total_stack_len < 1 { + return None; + } let top_stack_len = self.traversal_stack_top.len(); if top_stack_len > 0 { match self.traversal_stack_top.get_mut(top_stack_len - 1) { - None => { self.item_stack.pop(); } - Some(next_iter) => { - match next_iter.next() { - None => { - self.traversal_stack_top.pop(); - let popped = self.item_stack.pop(); - if just_added { return popped; } + None => { + self.item_stack.pop(); + } + Some(next_iter) => match next_iter.next() { + None => { + self.traversal_stack_top.pop(); + let popped = self.item_stack.pop(); + if just_added { + return popped; } - Some(node) => { - let (value, children) = node.$get_value_and_children(); - self.item_stack.push(value); - match children { - None => { return self.item_stack.pop(); } - Some(children) => { - self.traversal_stack_top.push(children); - just_added = true; - } + } + Some(node) => { + let (value, children) = node.$get_value_and_children(); + self.item_stack.push(value); + match children { + None => { + return self.item_stack.pop(); + } + Some(children) => { + self.traversal_stack_top.push(children); + just_added = true; } } } - } + }, } continue; } let bottom_stack_len = self.traversal_stack_bottom.len(); match self.traversal_stack_bottom.get_mut(bottom_stack_len - 1) { None => {} - Some(next_iter) => { - match next_iter.next() { - None => { - self.traversal_stack_bottom.pop(); - } - Some(node) => { - let (value, children) = node.$get_value_and_children(); - self.item_stack.push(value); - match children { - None => { return self.item_stack.pop(); } - Some(children) => self.traversal_stack_top.push(children) + Some(next_iter) => match next_iter.next() { + None => { + self.traversal_stack_bottom.pop(); + } + Some(node) => { + let (value, children) = node.$get_value_and_children(); + self.item_stack.push(value); + match children { + None => { + return self.item_stack.pop(); + } + Some(children) => { + self.traversal_stack_top.push(children) } } } - } + }, } } } @@ -78,4 +89,4 @@ macro_rules! dfs_postorder_leaves_next { }; } -pub (crate) use dfs_postorder_leaves_next; \ No newline at end of file +pub(crate) use dfs_postorder_leaves_next; diff --git a/src/leaves_iterators/depth_first/mut_borrow.rs b/src/leaves_iterators/depth_first/mut_borrow.rs index 7290fb1..5f93a82 100644 --- a/src/leaves_iterators/depth_first/mut_borrow.rs +++ b/src/leaves_iterators/depth_first/mut_borrow.rs @@ -1,54 +1,62 @@ -use alloc::vec::Vec; use crate::prelude::{ - MutBorrowedTreeNode, - BinaryChildren, - MutBorrowedBinaryTreeNode, LeavesIterator + BinaryChildren, LeavesIterator, MutBorrowedBinaryTreeNode, MutBorrowedTreeNode, }; +use alloc::vec::Vec; use super::dfs_postorder_leaves_next; pub struct MutBorrowedLeavesIterator<'a, Node, Iter> - where Node: MutBorrowedTreeNode<'a>, - Iter: Iterator { - - pub (crate) root: Option<&'a mut Node>, - pub (crate) traversal_stack_bottom: Vec, - pub (crate) traversal_stack_top: Vec, - pub (crate) item_stack: Vec +where + Node: MutBorrowedTreeNode<'a>, + Iter: Iterator, +{ + pub(crate) root: Option<&'a mut Node>, + pub(crate) traversal_stack_bottom: Vec, + pub(crate) traversal_stack_top: Vec, + pub(crate) item_stack: Vec, } -impl<'a, Node, Iter> Iterator for MutBorrowedLeavesIterator<'a, Node, Iter> - where Node: MutBorrowedTreeNode<'a>, - Iter: Iterator { - +impl<'a, Node, Iter> Iterator for MutBorrowedLeavesIterator<'a, Node, Iter> +where + Node: MutBorrowedTreeNode<'a>, + Iter: Iterator, +{ type Item = Node::MutBorrowedValue; - + dfs_postorder_leaves_next!(get_value_and_children_iter_mut); } -impl<'a, Node, Iter> LeavesIterator for MutBorrowedLeavesIterator<'a, Node, Iter> - where Node: MutBorrowedTreeNode<'a>, - Iter: Iterator {} +impl<'a, Node, Iter> LeavesIterator for MutBorrowedLeavesIterator<'a, Node, Iter> +where + Node: MutBorrowedTreeNode<'a>, + Iter: Iterator, +{ +} pub struct MutBorrowedBinaryLeavesIterator<'a, Node, Iter> - where Node: MutBorrowedBinaryTreeNode<'a>, - Iter: Iterator { - - pub (crate) root: Option<&'a mut Node>, - pub (crate) traversal_stack_bottom: Vec, - pub (crate) traversal_stack_top: Vec>, - pub (crate) item_stack: Vec, +where + Node: MutBorrowedBinaryTreeNode<'a>, + Iter: Iterator, +{ + pub(crate) root: Option<&'a mut Node>, + pub(crate) traversal_stack_bottom: Vec, + pub(crate) traversal_stack_top: Vec>, + pub(crate) item_stack: Vec, } -impl<'a, Node, Iter> Iterator for MutBorrowedBinaryLeavesIterator<'a, Node, Iter> - where Node: MutBorrowedBinaryTreeNode<'a>, - Iter: Iterator { - +impl<'a, Node, Iter> Iterator for MutBorrowedBinaryLeavesIterator<'a, Node, Iter> +where + Node: MutBorrowedBinaryTreeNode<'a>, + Iter: Iterator, +{ type Item = Node::MutBorrowedValue; - + dfs_postorder_leaves_next!(get_value_and_children_iter_mut); } -impl<'a, Node, Iter> LeavesIterator for MutBorrowedBinaryLeavesIterator<'a, Node, Iter> - where Node: MutBorrowedBinaryTreeNode<'a>, - Iter: Iterator {} \ No newline at end of file +impl<'a, Node, Iter> LeavesIterator for MutBorrowedBinaryLeavesIterator<'a, Node, Iter> +where + Node: MutBorrowedBinaryTreeNode<'a>, + Iter: Iterator, +{ +} diff --git a/src/leaves_iterators/depth_first/owned.rs b/src/leaves_iterators/depth_first/owned.rs index 25f0dba..a5911b3 100644 --- a/src/leaves_iterators/depth_first/owned.rs +++ b/src/leaves_iterators/depth_first/owned.rs @@ -1,51 +1,53 @@ +use crate::prelude::{BinaryChildren, LeavesIterator, OwnedBinaryTreeNode, OwnedTreeNode}; use alloc::vec::Vec; -use crate::prelude::{ - OwnedTreeNode, - BinaryChildren, - OwnedBinaryTreeNode, LeavesIterator -}; use super::dfs_postorder_leaves_next; pub struct OwnedLeavesIterator - where Node: OwnedTreeNode { - - pub (crate) root: Option, - pub (crate) traversal_stack_bottom: Vec, - pub (crate) traversal_stack_top: Vec, - pub (crate) item_stack: Vec, +where + Node: OwnedTreeNode, +{ + pub(crate) root: Option, + pub(crate) traversal_stack_bottom: Vec, + pub(crate) traversal_stack_top: Vec, + pub(crate) item_stack: Vec, } -impl<'a, Node> Iterator for OwnedLeavesIterator - where Node: OwnedTreeNode { - +impl<'a, Node> Iterator for OwnedLeavesIterator +where + Node: OwnedTreeNode, +{ type Item = Node::OwnedValue; - + dfs_postorder_leaves_next!(get_value_and_children); } -impl<'a, Node> LeavesIterator for OwnedLeavesIterator - where Node: OwnedTreeNode {} +impl<'a, Node> LeavesIterator for OwnedLeavesIterator where Node: OwnedTreeNode {} pub struct OwnedBinaryLeavesIterator - where Node: OwnedBinaryTreeNode, - Iter: Iterator { - - pub (crate) root: Option, - pub (crate) traversal_stack_bottom: Vec, - pub (crate) traversal_stack_top: Vec>, - pub (crate) item_stack: Vec, +where + Node: OwnedBinaryTreeNode, + Iter: Iterator, +{ + pub(crate) root: Option, + pub(crate) traversal_stack_bottom: Vec, + pub(crate) traversal_stack_top: Vec>, + pub(crate) item_stack: Vec, } -impl Iterator for OwnedBinaryLeavesIterator - where Node: OwnedBinaryTreeNode, - Iter: Iterator { - +impl Iterator for OwnedBinaryLeavesIterator +where + Node: OwnedBinaryTreeNode, + Iter: Iterator, +{ type Item = Node::OwnedValue; - + dfs_postorder_leaves_next!(get_value_and_children); } -impl LeavesIterator for OwnedBinaryLeavesIterator - where Node: OwnedBinaryTreeNode, - Iter: Iterator {} \ No newline at end of file +impl LeavesIterator for OwnedBinaryLeavesIterator +where + Node: OwnedBinaryTreeNode, + Iter: Iterator, +{ +} diff --git a/src/leaves_iterators/mod.rs b/src/leaves_iterators/mod.rs index 6213563..1e7cf7a 100644 --- a/src/leaves_iterators/mod.rs +++ b/src/leaves_iterators/mod.rs @@ -1,2 +1,4 @@ -pub mod breadth_first; -pub mod depth_first; \ No newline at end of file +pub(crate) mod ancestors_breadth_first; +pub(crate) mod ancestors_depth_first; +pub(crate) mod breadth_first; +pub(crate) mod depth_first; diff --git a/src/prelude.rs b/src/prelude.rs index 87a4469..b61b2eb 100644 --- a/src/prelude.rs +++ b/src/prelude.rs @@ -1,69 +1,38 @@ +use alloc::boxed::Box; +use alloc::vec::{IntoIter, Vec}; use core::fmt::Debug; use core::iter::FlatMap; use core::slice::{Iter, IterMut}; -use alloc::boxed::Box; -use alloc::vec::{IntoIter, Vec}; #[cfg(feature = "serde")] -use serde_derive::{Serialize, Deserialize}; -use streaming_iterator::{ - StreamingIterator, - StreamingIteratorMut -}; +use serde_derive::{Deserialize, Serialize}; +use streaming_iterator::{StreamingIterator, StreamingIteratorMut}; use super::bfs_iterators::{ - owned::{ - OwnedBFSIterator, - OwnedBinaryBFSIterator - }, - mut_borrow::{ - MutBorrowedBFSIterator, - MutBorrowedBinaryBFSIterator - }, - borrow::{ - BorrowedBFSIterator, - BorrowedBinaryBFSIterator - }, + borrow::{BorrowedBFSIterator, BorrowedBinaryBFSIterator}, + mut_borrow::{MutBorrowedBFSIterator, MutBorrowedBinaryBFSIterator}, + owned::{OwnedBFSIterator, OwnedBinaryBFSIterator}, }; use super::dfs_preorder_iterators::{ - owned::{ - OwnedDFSPreorderIterator, - OwnedBinaryDFSPreorderIterator - }, - mut_borrow::{ - MutBorrowedDFSPreorderIterator, - MutBorrowedBinaryDFSPreorderIterator - }, - borrow::{ - BorrowedDFSPreorderIterator, - BorrowedBinaryDFSPreorderIterator - } + borrow::{BorrowedBinaryDFSPreorderIterator, BorrowedDFSPreorderIterator}, + mut_borrow::{MutBorrowedBinaryDFSPreorderIterator, MutBorrowedDFSPreorderIterator}, + owned::{OwnedBinaryDFSPreorderIterator, OwnedDFSPreorderIterator}, }; use super::dfs_inorder_iterators::{ + borrow::BorrowedDFSInorderIterator, mut_borrow::MutBorrowedDFSInorderIterator, owned::OwnedDFSInorderIterator, - mut_borrow::MutBorrowedDFSInorderIterator, - borrow::BorrowedDFSInorderIterator, }; use super::dfs_postorder_iterators::{ - owned::{ - OwnedDFSPostorderIterator, - OwnedBinaryDFSPostorderIterator - }, - mut_borrow::{ - MutBorrowedDFSPostorderIterator, - MutBorrowedBinaryDFSPostorderIterator - }, - borrow::{ - BorrowedDFSPostorderIterator, - BorrowedBinaryDFSPostorderIterator - } + borrow::{BorrowedBinaryDFSPostorderIterator, BorrowedDFSPostorderIterator}, + mut_borrow::{MutBorrowedBinaryDFSPostorderIterator, MutBorrowedDFSPostorderIterator}, + owned::{OwnedBinaryDFSPostorderIterator, OwnedDFSPostorderIterator}, }; -/// A default implemenation of a binary tree node. This struct -/// provides a series of tree traversal utilities to allow +/// A default implemenation of a binary tree node. This struct +/// provides a series of tree traversal utilities to allow /// you to easily work with and modify binary trees. #[derive(Clone, Debug, Default)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] @@ -76,8 +45,8 @@ pub struct BinaryTreeNode { pub right: Option>>, } -/// A default implemenation of a tree node. This struct -/// provides a series of tree traversal utilities to allow +/// A default implemenation of a tree node. This struct +/// provides a series of tree traversal utilities to allow /// you to easily work with and modify arbitrary trees. #[derive(Clone, Debug, Default)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] @@ -85,22 +54,22 @@ pub struct TreeNode { /// This node's value pub value: T, /// The children of the current node. - pub children: Option>> + pub children: Option>>, } -pub trait TreeIterator : Iterator { - /// This method converts the current iterator into +pub trait TreeIterator: Iterator { + /// This method converts the current iterator into /// an iterator that will yield only the leaves of the tree. Iteration - /// still proceeds in either a breadth first search (if called on a - /// breadth first iterator) or depth first post-order search (if called - /// on a depth first pre-, in-, or post-order iterator). This method + /// still proceeds in either a breadth first search (if called on a + /// breadth first iterator) or depth first post-order search (if called + /// on a depth first pre-, in-, or post-order iterator). This method /// is safe to call at any point during iteration and will never panic. - /// - /// A leaf is defined as: Any tree node that has no children. Given a tree - /// of the following shape, this iterator would always yield values in the + /// + /// A leaf is defined as: Any tree node that has no children. Given a tree + /// of the following shape, this iterator would always yield values in the /// following order (regardless of iteration type): /// 3, 4, 5, 10 - /// + /// /// ```ignore /// 0 /// / \ @@ -116,14 +85,14 @@ pub trait TreeIterator : Iterator { /// \ /// 10 /// ``` - /// + /// /// ```rust /// // Example usage: /// use tree_iterators_rs::{ /// prelude::*, /// examples::create_example_binary_tree /// }; - /// + /// /// let root = create_example_binary_tree(); /// for leaf in root.bfs().leaves() { /// println!("{}", leaf); @@ -133,29 +102,29 @@ pub trait TreeIterator : Iterator { /// This method will panic if called after an element has already /// been yielded from the iterator it is called on! - /// + /// /// This method attaches the ancestors of each node to the node - /// during iteration. This operation converts the current iterator - /// into a streaming iterator. - /// - /// For Breadth First Search iterators, this converts the queue-based + /// during iteration. This operation converts the current iterator + /// into a streaming iterator. + /// + /// For Breadth First Search iterators, this converts the queue-based /// iterator into an iterative deepening iterator. This can cause performance /// degredation, but is impossible to avoid while providing this data. - /// + /// /// The order in which elements are yielded remains unchanged, but /// each will now be yielded with its ancestor stack attached. That - /// means that for our example tree, each element will be replaced + /// means that for our example tree, each element will be replaced /// by the following: - /// - 0 -> \[0\], - /// - 1 -> \[0, 1\], - /// - 2 -> \[0, 2\], - /// - 3 -> \[0, 1, 3\], - /// - 4 -> \[0, 1, 4\], - /// - 5 -> \[0, 2, 5\], - /// - 6 -> \[0, 2, 6\], - /// - 7 -> \[0, 2, 6, 7\], - /// - 8 -> \[0, 2, 6, 7, 8\], - /// - 9 -> \[0, 2, 6, 7, 8, 9\], + /// - 0 -> \[0\], + /// - 1 -> \[0, 1\], + /// - 2 -> \[0, 2\], + /// - 3 -> \[0, 1, 3\], + /// - 4 -> \[0, 1, 4\], + /// - 5 -> \[0, 2, 5\], + /// - 6 -> \[0, 2, 6\], + /// - 7 -> \[0, 2, 6, 7\], + /// - 8 -> \[0, 2, 6, 7, 8\], + /// - 9 -> \[0, 2, 6, 7, 8, 9\], /// - 10 -> \[0, 2, 6, 7, 8, 9, 10\] /// ```ignore /// Example Tree: @@ -173,18 +142,18 @@ pub trait TreeIterator : Iterator { /// \ /// 10 /// ``` - /// + /// /// More technical details: - /// + /// /// Because this operation transforms the iterator into a StreamingIterator, - /// the slices cannot be saved and used across loop iterations, as the slice - /// points to internal iterator memory and is altered with the .next() call. - /// Each slice must be converted into a Vec by the caller to save - /// them for later. This operation will incur a performance penalty + /// the slices cannot be saved and used across loop iterations, as the slice + /// points to internal iterator memory and is altered with the .next() call. + /// Each slice must be converted into a Vec by the caller to save + /// them for later. This operation will incur a performance penalty /// and this library does not assume you want that performance penalty. - /// + /// /// Since this iterator is no longer a Rust Iterator, for loops will - /// no longer work. See details on how to work around this in the + /// no longer work. See details on how to work around this in the /// [streaming-iterator](https://crates.io/crates/streaming-iterator) crate. /// ```rust /// // Example usage: @@ -193,14 +162,14 @@ pub trait TreeIterator : Iterator { /// prelude::*, /// examples::create_example_binary_tree /// }; - /// + /// /// let root = create_example_binary_tree(); /// let mut result = String::new(); - /// + /// /// // any iterator method can be swapped in here - /// root.dfs_preorder() + /// root.dfs_preorder() /// .attach_ancestors() - /// .filter(|slice| + /// .filter(|slice| /// slice.iter().all(|value| *value % 2 == 0) /// ) /// .map(|slice| slice[slice.len() - 1]) @@ -215,18 +184,18 @@ pub trait TreeIterator : Iterator { } pub trait TreeIteratorMut: Iterator { - /// This method converts the current iterator into + /// This method converts the current iterator into /// an iterator that will yield only the leaves of the tree. Iteration - /// still proceeds in either a breadth first search (if called on a - /// breadth first iterator) or depth first post-order search (if called - /// on a depth first pre-, in-, or post-order iterator). This method + /// still proceeds in either a breadth first search (if called on a + /// breadth first iterator) or depth first post-order search (if called + /// on a depth first pre-, in-, or post-order iterator). This method /// is safe to call at any point during iteration and will never panic. - /// - /// A leaf is defined as: Any tree node that has no children. Given a tree - /// of the following shape, this iterator would always yield values in the + /// + /// A leaf is defined as: Any tree node that has no children. Given a tree + /// of the following shape, this iterator would always yield values in the /// following order (regardless of iteration type): /// 3, 4, 5, 10 - /// + /// /// ```ignore /// 0 /// / \ @@ -242,14 +211,14 @@ pub trait TreeIteratorMut: Iterator { /// \ /// 10 /// ``` - /// + /// /// ```ignore /// // Example usage: /// use tree_iterators_rs::{ /// prelude::*, /// examples::create_example_binary_tree /// }; - /// + /// /// let root = create_example_binary_tree(); /// for leaf in root.your_chosen_iterator_method().leaves() { /// println!("{}", leaf); @@ -259,29 +228,29 @@ pub trait TreeIteratorMut: Iterator { /// This method will panic if called after an element has already /// been yielded from the iterator it is called on! - /// + /// /// This method attaches the ancestors of each node to the node - /// during iteration. This operation converts the current iterator - /// into a streaming iterator. - /// - /// For Breadth First Search iterators, this converts the queue-based + /// during iteration. This operation converts the current iterator + /// into a streaming iterator. + /// + /// For Breadth First Search iterators, this converts the queue-based /// iterator into an iterative deepening iterator. This can have performanc /// impacts. - /// + /// /// The order in which elements are yielded remains unchanged, but /// each will now be yielded with its ancestor stack attached. That - /// means that for our example tree, each element will be replaced + /// means that for our example tree, each element will be replaced /// by the following: - /// - 0 -> \[0\], - /// - 1 -> \[0, 1\], - /// - 2 -> \[0, 2\], - /// - 3 -> \[0, 1, 3\], - /// - 4 -> \[0, 1, 4\], - /// - 5 -> \[0, 2, 5\], - /// - 6 -> \[0, 2, 6\], - /// - 7 -> \[0, 2, 6, 7\], - /// - 8 -> \[0, 2, 6, 7, 8\], - /// - 9 -> \[0, 2, 6, 7, 8, 9\], + /// - 0 -> \[0\], + /// - 1 -> \[0, 1\], + /// - 2 -> \[0, 2\], + /// - 3 -> \[0, 1, 3\], + /// - 4 -> \[0, 1, 4\], + /// - 5 -> \[0, 2, 5\], + /// - 6 -> \[0, 2, 6\], + /// - 7 -> \[0, 2, 6, 7\], + /// - 8 -> \[0, 2, 6, 7, 8\], + /// - 9 -> \[0, 2, 6, 7, 8, 9\], /// - 10 -> \[0, 2, 6, 7, 8, 9, 10\] /// ```ignore /// Example Tree: @@ -299,18 +268,18 @@ pub trait TreeIteratorMut: Iterator { /// \ /// 10 /// ``` - /// + /// /// More technical details: - /// + /// /// Because this operation transforms the iterator into a StreamingIterator, - /// the slices cannot be saved and used across loop iterations, as the slice - /// points to internal iterator memory and is altered with the .next() call. - /// Each slice must be converted into a Vec by the caller to save - /// them for later. This operation will incur a performance penalty + /// the slices cannot be saved and used across loop iterations, as the slice + /// points to internal iterator memory and is altered with the .next() call. + /// Each slice must be converted into a Vec by the caller to save + /// them for later. This operation will incur a performance penalty /// and this library does not assume you want that performance penalty. - /// + /// /// Since this iterator is no longer a Rust Iterator, for loops will - /// no longer work. See details on how to work around this in the + /// no longer work. See details on how to work around this in the /// [streaming-iterator](https://crates.io/crates/streaming-iterator) crate. /// ```ignore /// // Example usage: @@ -319,12 +288,12 @@ pub trait TreeIteratorMut: Iterator { /// prelude::*, /// examples::create_example_tree /// }; - /// + /// /// let root = create_example_tree(); /// let mut result = String::new(); /// root.your_chosen_iterator_method() /// .attach_ancestors() - /// .filter(|slice| + /// .filter(|slice| /// slice.iter().all(|value| **value % 2 == 0) /// ) /// .map(|slice| slice[slice.len() - 1]) @@ -338,36 +307,47 @@ pub trait TreeIteratorMut: Iterator { fn attach_ancestors(self) -> impl AncestorsIteratorMut; } -pub trait LeavesIterator : Iterator {} -pub trait AncestorsIterator : StreamingIterator {} -pub trait AncestorsIteratorMut : StreamingIteratorMut {} +/// This trait is a placeholder to allow easy addition of features to the leaves iterator in the future. It simply wraps Iterator. +/// For now it simply wraps Iterator +pub trait LeavesIterator: Iterator {} +pub trait AncestorsIterator: StreamingIterator { + fn leaves(self) -> impl AncestorsLeavesIterator; +} + +/// this trait provides a consistent trait to simplify this library's public interface and documentation. +pub trait AncestorsIteratorMut: StreamingIteratorMut { + fn leaves(self) -> impl AncestorsLeavesIteratorMut; +} + +/// this trait provides a consistent trait to simplify this library's public interface and documentation. +/// For now it simply wraps StreamingIterator. +pub trait AncestorsLeavesIterator: StreamingIterator {} + +/// This trait provides a consistent trait to simplify this library's public interface and documentation. +/// For now it simply wraps StreamingIterator. +pub trait AncestorsLeavesIteratorMut: StreamingIteratorMut {} /// Helper type to define the BinaryTreeNode's /// Children iterator type. -pub (crate) type BinaryChildren = FlatMap< - core::array::IntoIter< - Option, - 2 - >, - Option, - fn(Option) -> Option ->; +pub(crate) type BinaryChildren = + FlatMap, 2>, Option, fn(Option) -> Option>; /// A binary tree node where getting its children consumes its value. -pub trait OwnedBinaryTreeNode - where Self: Sized { - +pub trait OwnedBinaryTreeNode +where + Self: Sized, +{ /// The value of each node in the tree. type OwnedValue; - /// This method gets the value and left and right children from this node, - /// consuming it in the process. The other methods of this trait assume that - /// the children do not contain any circular references. If they do, + /// This method gets the value and left and right children from this node, + /// consuming it in the process. The other methods of this trait assume that + /// the children do not contain any circular references. If they do, /// it will create an infinite loop. fn get_value_and_children_binary(self) -> (Self::OwnedValue, [Option; 2]); - /// This method gets the value and children from this node, consuming it - /// in the process. The other methods of this trait assume that the 'Children' + /// This method gets the value and children from this node, consuming it + /// in the process. The other methods of this trait assume that the 'Children' /// list does not contain any circular references. If it does, it will create /// an infinite loop. fn get_value_and_children(self) -> (Self::OwnedValue, Option>) { @@ -375,22 +355,23 @@ pub trait OwnedBinaryTreeNode ( value, Some( - children.into_iter() - .flat_map(opt_to_opt as fn(Option) -> Option) - ) + children + .into_iter() + .flat_map(opt_to_opt as fn(Option) -> Option), + ), ) } /// This method retrieves an iterator that can be used to perform /// Breadth First (Queue - specifically VecDeque-based) searches of a tree. - /// + /// /// A Breadth First Search (BFS) is defined as: - /// - /// A tree traversal that involves breadth-first searching a tree - /// from the top down. Given a tree of the following shape, this - /// traversal type would traverse the elements in the order + /// + /// A tree traversal that involves breadth-first searching a tree + /// from the top down. Given a tree of the following shape, this + /// traversal type would traverse the elements in the order /// 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10. - /// + /// /// In this traversal, we scan each level of the tree from left to /// right before going down to the next level. /// ```ignore @@ -408,21 +389,21 @@ pub trait OwnedBinaryTreeNode /// \ /// 10 /// ``` - /// + /// fn bfs(self) -> impl TreeIteratorMut { OwnedBinaryBFSIterator::new(self) } /// This method retrieves an iterator that can be used to perform /// Depth First Preorder searches of a tree. - /// + /// /// A Depth First Preorder search is defined as: - /// - /// A tree traversal that involves depth-first searching a tree - /// from the top down. Given a tree of the following shape, this + /// + /// A tree traversal that involves depth-first searching a tree + /// from the top down. Given a tree of the following shape, this /// traversal type would traverse the elements in the order /// 0, 1, 3, 4, 2, 5, 6, 7, 8, 9, 10. - /// + /// /// In this traversal, each node will only be traversed before any /// of its children have been traversed. /// ```ignore @@ -440,23 +421,23 @@ pub trait OwnedBinaryTreeNode /// \ /// 10 /// ``` - /// + /// fn dfs_preorder(self) -> impl TreeIteratorMut { OwnedBinaryDFSPreorderIterator::new(self) } /// This method retrieves an iterator that can be used to perform /// Depth First In Order searches of a tree. - /// + /// /// A Depth First In Order search is defined as: - /// - /// A tree traversal that involves depth-first searching a tree - /// from the left to the right. Given a tree of the following shape, - /// this traversal type would traverse + /// + /// A tree traversal that involves depth-first searching a tree + /// from the left to the right. Given a tree of the following shape, + /// this traversal type would traverse /// the elements in the order /// 3, 1, 4, 0, 5, 2, 7, 9, 10, 8, 6. - /// - /// In this traversal, each node will be traversed after its left + /// + /// In this traversal, each node will be traversed after its left /// child and before its right child. /// ```ignore /// 0 @@ -473,22 +454,22 @@ pub trait OwnedBinaryTreeNode /// \ /// 10 /// ``` - /// + /// fn dfs_inorder(self) -> impl TreeIteratorMut { OwnedDFSInorderIterator::new(self) } /// This method retrieves an iterator that can be used to perform /// Depth First Postorder searches of a tree. - /// - /// A Depth First Postorder search (referred to as DFS Postorder) + /// + /// A Depth First Postorder search (referred to as DFS Postorder) /// is defined as: - /// - /// A tree traversal that involves depth-first searching a tree - /// from the bottom up. Given a tree of the following shape, this - /// traversal type would traverse the elements in the order + /// + /// A tree traversal that involves depth-first searching a tree + /// from the bottom up. Given a tree of the following shape, this + /// traversal type would traverse the elements in the order /// 3, 4, 1, 5, 10, 9, 8, 7, 6, 2, 0. - /// + /// /// In this traversal, each node will only be traversed after all /// of its children have been traversed. /// ```ignore @@ -506,8 +487,8 @@ pub trait OwnedBinaryTreeNode /// \ /// 10 /// ``` - /// - /// This traversal type guarantees that getChildren() will only be + /// + /// This traversal type guarantees that getChildren() will only be /// called once per node of the tree. /// fn dfs_postorder(self) -> impl TreeIteratorMut { @@ -516,32 +497,33 @@ pub trait OwnedBinaryTreeNode } /// A tree node where getting its children consumes its value. -pub trait OwnedTreeNode - where Self: Sized { - +pub trait OwnedTreeNode +where + Self: Sized, +{ /// The value of each node in the tree. type OwnedValue: Sized; - /// The type of iterator that can be used to iterate over each node's children + /// The type of iterator that can be used to iterate over each node's children /// collection. type OwnedChildren: Iterator; - /// This method gets the value and children from this node, consuming it - /// in the process. The other methods of this trait assume that the 'Children' + /// This method gets the value and children from this node, consuming it + /// in the process. The other methods of this trait assume that the 'Children' /// list does not contain any circular references. If it does, it will create /// an infinite loop. fn get_value_and_children(self) -> (Self::OwnedValue, Option); /// This method retrieves an iterator that can be used to perform /// Breadth First (Queue - specifically VecDeque-based) searches of a tree. - /// + /// /// A Breadth First Search (BFS) is defined as: - /// - /// A tree traversal that involves breadth-first searching a tree - /// from the top down. Given a tree of the following shape, this - /// traversal type would traverse the elements in the order + /// + /// A tree traversal that involves breadth-first searching a tree + /// from the top down. Given a tree of the following shape, this + /// traversal type would traverse the elements in the order /// 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10. - /// + /// /// In this traversal, we scan each level of the tree from left to /// right before going down to the next level. /// ```ignore @@ -559,23 +541,23 @@ pub trait OwnedTreeNode /// \ /// 10 /// ``` - /// + /// fn bfs(self) -> impl TreeIteratorMut { OwnedBFSIterator::new(self) } - /// This method retrieves an iterator that can be used to perform - /// Depth First Preorder searches of a tree. - /// - /// A Depth First Preorder search is defined as: - /// - /// A tree traversal that involves depth-first searching a tree - /// from the top down. Given a tree of the following shape, this - /// traversal type would traverse the elements in the order - /// 0, 1, 3, 4, 2, 5, 6, 7, 8, 9, 10. - /// - /// In this traversal, each node will only be traversed before any - /// of its children have been traversed. + /// This method retrieves an iterator that can be used to perform + /// Depth First Preorder searches of a tree. + /// + /// A Depth First Preorder search is defined as: + /// + /// A tree traversal that involves depth-first searching a tree + /// from the top down. Given a tree of the following shape, this + /// traversal type would traverse the elements in the order + /// 0, 1, 3, 4, 2, 5, 6, 7, 8, 9, 10. + /// + /// In this traversal, each node will only be traversed before any + /// of its children have been traversed. /// ```ignore /// 0 /// / \ @@ -591,22 +573,22 @@ pub trait OwnedTreeNode /// \ /// 10 /// ``` - /// + /// fn dfs_preorder(self) -> impl TreeIteratorMut { OwnedDFSPreorderIterator::new(self) } /// This method retrieves an iterator that can be used to perform /// Depth First Postorder searches of a tree. - /// - /// A Depth First Postorder search (referred to as DFS Postorder) + /// + /// A Depth First Postorder search (referred to as DFS Postorder) /// is defined as: - /// - /// A tree traversal that involves depth-first searching a tree - /// from the bottom up. Given a tree of the following shape, this - /// traversal type would traverse the elements in the order + /// + /// A tree traversal that involves depth-first searching a tree + /// from the bottom up. Given a tree of the following shape, this + /// traversal type would traverse the elements in the order /// 3, 4, 1, 5, 10, 9, 8, 7, 6, 2, 0. - /// + /// /// In this traversal, each node will only be traversed after all /// of its children have been traversed. /// ```ignore @@ -624,8 +606,8 @@ pub trait OwnedTreeNode /// \ /// 10 /// ``` - /// - /// This traversal type guarantees that getChildren() will only be + /// + /// This traversal type guarantees that getChildren() will only be /// called once per node of the tree. /// fn dfs_postorder(self) -> impl TreeIteratorMut { @@ -635,41 +617,47 @@ pub trait OwnedTreeNode /// A binary tree node where getting its children mutably borrows its value. pub trait MutBorrowedBinaryTreeNode<'a> - where Self: Sized + 'a { - +where + Self: Sized + 'a, +{ /// A mutable reference to the value of each node in the tree. type MutBorrowedValue; - /// This method gets the value and left and right children from this node, - /// borrowing it as mutable in the process. The other methods of this trait - /// assume that the children do not contain any circular references. If they do, + /// This method gets the value and left and right children from this node, + /// borrowing it as mutable in the process. The other methods of this trait + /// assume that the children do not contain any circular references. If they do, /// it will create an infinite loop. - fn get_value_and_children_binary_iter_mut(&'a mut self) -> (Self::MutBorrowedValue, [Option<&'a mut Self>; 2]); + fn get_value_and_children_binary_iter_mut( + &'a mut self, + ) -> (Self::MutBorrowedValue, [Option<&'a mut Self>; 2]); - /// This method gets the value and children from this node. The other - /// methods of this trait assume that the 'Children' list does not contain + /// This method gets the value and children from this node. The other + /// methods of this trait assume that the 'Children' list does not contain /// any circular references. If there are, an inifite loop will result. - fn get_value_and_children_iter_mut(&'a mut self) -> (Self::MutBorrowedValue, Option>) { + fn get_value_and_children_iter_mut( + &'a mut self, + ) -> (Self::MutBorrowedValue, Option>) { let (value, children) = self.get_value_and_children_binary_iter_mut(); ( value, Some( - children.into_iter() - .flat_map(opt_to_opt as fn(Option<&'a mut Self>) -> Option<&'a mut Self>) - ) + children + .into_iter() + .flat_map(opt_to_opt as fn(Option<&'a mut Self>) -> Option<&'a mut Self>), + ), ) } /// This method retrieves an iterator that can be used to perform /// Breadth First (Queue - specifically VecDeque-based) searches of a tree. - /// + /// /// A Breadth First Search (BFS) is defined as: - /// - /// A tree traversal that involves breadth-first searching a tree - /// from the top down. Given a tree of the following shape, this - /// traversal type would traverse the elements in the order + /// + /// A tree traversal that involves breadth-first searching a tree + /// from the top down. Given a tree of the following shape, this + /// traversal type would traverse the elements in the order /// 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10. - /// + /// /// In this traversal, we scan each level of the tree from left to /// right before going down to the next level. /// ```ignore @@ -687,21 +675,21 @@ pub trait MutBorrowedBinaryTreeNode<'a> /// \ /// 10 /// ``` - /// + /// fn bfs_iter_mut(&'a mut self) -> impl TreeIteratorMut { MutBorrowedBinaryBFSIterator::new(self) } /// This method retrieves an iterator that can be used to perform /// Depth First Preorder searches of a tree. - /// + /// /// A Depth First Preorder search is defined as: - /// - /// A tree traversal that involves depth-first searching a tree - /// from the top down. Given a tree of the following shape, this + /// + /// A tree traversal that involves depth-first searching a tree + /// from the top down. Given a tree of the following shape, this /// traversal type would traverse the elements in the order /// 0, 1, 3, 4, 2, 5, 6, 7, 8, 9, 10. - /// + /// /// In this traversal, each node will only be traversed before any /// of its children have been traversed. /// ```ignore @@ -719,23 +707,23 @@ pub trait MutBorrowedBinaryTreeNode<'a> /// \ /// 10 /// ``` - /// + /// fn dfs_preorder_iter_mut(&'a mut self) -> impl TreeIteratorMut { MutBorrowedBinaryDFSPreorderIterator::new(self) } /// This method retrieves an iterator that can be used to perform /// Depth First In Order searches of a tree. - /// + /// /// A Depth First In Order search is defined as: - /// - /// A tree traversal that involves depth-first searching a tree - /// from the left to the right. Given a tree of the following shape, - /// this traversal type would traverse + /// + /// A tree traversal that involves depth-first searching a tree + /// from the left to the right. Given a tree of the following shape, + /// this traversal type would traverse /// the elements in the order /// 3, 1, 4, 0, 5, 2, 7, 9, 10, 8, 6. - /// - /// In this traversal, each node will be traversed after its left + /// + /// In this traversal, each node will be traversed after its left /// child and before its right child. /// ```ignore /// 0 @@ -752,22 +740,22 @@ pub trait MutBorrowedBinaryTreeNode<'a> /// \ /// 10 /// ``` - /// + /// fn dfs_inorder_iter_mut(&'a mut self) -> impl TreeIteratorMut { MutBorrowedDFSInorderIterator::new(self) } /// This method retrieves an iterator that can be used to perform /// Depth First Postorder searches of a tree. - /// - /// A Depth First Postorder search (referred to as DFS Postorder) + /// + /// A Depth First Postorder search (referred to as DFS Postorder) /// is defined as: - /// - /// A tree traversal that involves depth-first searching a tree - /// from the bottom up. Given a tree of the following shape, this - /// traversal type would traverse the elements in the order + /// + /// A tree traversal that involves depth-first searching a tree + /// from the bottom up. Given a tree of the following shape, this + /// traversal type would traverse the elements in the order /// 3, 4, 1, 5, 10, 9, 8, 7, 6, 2, 0. - /// + /// /// In this traversal, each node will only be traversed after all /// of its children have been traversed. /// ```ignore @@ -785,8 +773,8 @@ pub trait MutBorrowedBinaryTreeNode<'a> /// \ /// 10 /// ``` - /// - /// This traversal type guarantees that getChildren() will only be + /// + /// This traversal type guarantees that getChildren() will only be /// called once per node of the tree. /// fn dfs_postorder_iter_mut(&'a mut self) -> impl TreeIteratorMut { @@ -795,34 +783,37 @@ pub trait MutBorrowedBinaryTreeNode<'a> } /// A tree node where getting its children mutably borrows its value. -pub trait MutBorrowedTreeNode<'a> - where Self: Sized + 'a { - +pub trait MutBorrowedTreeNode<'a> +where + Self: Sized + 'a, +{ /// A mutable reference to the value of each node in the tree. type MutBorrowedValue: Sized; - /// The type of iterator that can be used to iterate over each node's children + /// The type of iterator that can be used to iterate over each node's children /// collection. type MutBorrowedChildren: Iterator; - /// This method gets the value and children from this node. The other - /// methods of this trait assume that the 'Children' list does not contain + /// This method gets the value and children from this node. The other + /// methods of this trait assume that the 'Children' list does not contain /// any circular references. If there are, an inifite loop will result. - fn get_value_and_children_iter_mut(&'a mut self) -> (Self::MutBorrowedValue, Option); + fn get_value_and_children_iter_mut( + &'a mut self, + ) -> (Self::MutBorrowedValue, Option); /// This method retrieves an iterator that can be used to perform - /// Breadth First (Queue - specifically VecDeque-based) searches of a tree. If performance is + /// Breadth First (Queue - specifically VecDeque-based) searches of a tree. If performance is /// not a serious concern, a Breadth First (iterative deepening) search /// (referred to as BFS in this library) should be preferred to make /// debugging easier. - /// + /// /// A Breadth First Search (BFS) is defined as: - /// - /// A tree traversal that involves breadth-first searching a tree - /// from the top down. Given a tree of the following shape, this - /// traversal type would traverse the elements in the order + /// + /// A tree traversal that involves breadth-first searching a tree + /// from the top down. Given a tree of the following shape, this + /// traversal type would traverse the elements in the order /// 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10. - /// + /// /// In this traversal, we scan each level of the tree from left to /// right before going down to the next level. /// ```ignore @@ -840,23 +831,23 @@ pub trait MutBorrowedTreeNode<'a> /// \ /// 10 /// ``` - /// + /// fn bfs_iter_mut(&'a mut self) -> impl TreeIteratorMut { MutBorrowedBFSIterator::new(self) } - /// This method retrieves an iterator that can be used to perform - /// Depth First Preorder searches of a tree. - /// - /// A Depth First Preorder search is defined as: - /// - /// A tree traversal that involves depth-first searching a tree - /// from the top down. Given a tree of the following shape, this - /// traversal type would traverse the elements in the order - /// 0, 1, 3, 4, 2, 5, 6, 7, 8, 9, 10. - /// - /// In this traversal, each node will only be traversed before any - /// of its children have been traversed. + /// This method retrieves an iterator that can be used to perform + /// Depth First Preorder searches of a tree. + /// + /// A Depth First Preorder search is defined as: + /// + /// A tree traversal that involves depth-first searching a tree + /// from the top down. Given a tree of the following shape, this + /// traversal type would traverse the elements in the order + /// 0, 1, 3, 4, 2, 5, 6, 7, 8, 9, 10. + /// + /// In this traversal, each node will only be traversed before any + /// of its children have been traversed. /// ```ignore /// 0 /// / \ @@ -872,22 +863,22 @@ pub trait MutBorrowedTreeNode<'a> /// \ /// 10 /// ``` - /// + /// fn dfs_preorder_iter_mut(&'a mut self) -> impl TreeIteratorMut { MutBorrowedDFSPreorderIterator::new(self) } /// This method retrieves an iterator that can be used to perform /// Depth First Postorder searches of a tree. - /// - /// A Depth First Postorder search (referred to as DFS Postorder) + /// + /// A Depth First Postorder search (referred to as DFS Postorder) /// is defined as: - /// - /// A tree traversal that involves depth-first searching a tree - /// from the bottom up. Given a tree of the following shape, this - /// traversal type would traverse the elements in the order + /// + /// A tree traversal that involves depth-first searching a tree + /// from the bottom up. Given a tree of the following shape, this + /// traversal type would traverse the elements in the order /// 3, 4, 1, 5, 10, 9, 8, 7, 6, 2, 0. - /// + /// /// In this traversal, each node will only be traversed after all /// of its children have been traversed. /// ```ignore @@ -905,8 +896,8 @@ pub trait MutBorrowedTreeNode<'a> /// \ /// 10 /// ``` - /// - /// This traversal type guarantees that getChildren() will only be + /// + /// This traversal type guarantees that getChildren() will only be /// called once per node of the tree. /// fn dfs_postorder_iter_mut(&'a mut self) -> impl TreeIteratorMut { @@ -916,41 +907,46 @@ pub trait MutBorrowedTreeNode<'a> /// A binary tree node where getting its children borrows its value. pub trait BorrowedBinaryTreeNode<'a> - where Self: Sized + 'a { - +where + Self: Sized + 'a, +{ /// A reference to the value of each node in the tree. type BorrowedValue; - /// This method gets the value and left and right children from this node, - /// borrowing it in the process. The other methods of this trait - /// assume that the children do not contain any circular references. If they do, + /// This method gets the value and left and right children from this node, + /// borrowing it in the process. The other methods of this trait + /// assume that the children do not contain any circular references. If they do, /// it will create an infinite loop. - fn get_value_and_children_binary_iter(&'a self) -> (Self::BorrowedValue, [Option<&'a Self>; 2]); + fn get_value_and_children_binary_iter(&'a self) + -> (Self::BorrowedValue, [Option<&'a Self>; 2]); - /// This method gets the value and children from this node, consuming it - /// in the process. The other methods of this trait assume that the 'Children' + /// This method gets the value and children from this node, consuming it + /// in the process. The other methods of this trait assume that the 'Children' /// list does not contain and circular references back to parent nodes. - fn get_value_and_children_iter(&'a self) -> (Self::BorrowedValue, Option>) { + fn get_value_and_children_iter( + &'a self, + ) -> (Self::BorrowedValue, Option>) { let (value, children) = self.get_value_and_children_binary_iter(); ( value, Some( - children.into_iter() - .flat_map(opt_to_opt as fn(Option<&'a Self>) -> Option<&'a Self>) - ) + children + .into_iter() + .flat_map(opt_to_opt as fn(Option<&'a Self>) -> Option<&'a Self>), + ), ) } /// This method retrieves an iterator that can be used to perform /// Breadth First (Queue - specifically VecDeque-based) searches of a tree. - /// + /// /// A Breadth First Search (BFS) is defined as: - /// - /// A tree traversal that involves breadth-first searching a tree - /// from the top down. Given a tree of the following shape, this - /// traversal type would traverse the elements in the order + /// + /// A tree traversal that involves breadth-first searching a tree + /// from the top down. Given a tree of the following shape, this + /// traversal type would traverse the elements in the order /// 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10. - /// + /// /// In this traversal, we scan each level of the tree from left to /// right before going down to the next level. /// ```ignore @@ -968,21 +964,21 @@ pub trait BorrowedBinaryTreeNode<'a> /// \ /// 10 /// ``` - /// + /// fn bfs_iter(&'a self) -> impl TreeIterator { BorrowedBinaryBFSIterator::new(self) } /// This method retrieves an iterator that can be used to perform /// Depth First Preorder searches of a tree. - /// + /// /// A Depth First Preorder search is defined as: - /// - /// A tree traversal that involves depth-first searching a tree - /// from the top down. Given a tree of the following shape, this + /// + /// A tree traversal that involves depth-first searching a tree + /// from the top down. Given a tree of the following shape, this /// traversal type would traverse the elements in the order /// 0, 1, 3, 4, 2, 5, 6, 7, 8, 9, 10. - /// + /// /// In this traversal, each node will only be traversed before any /// of its children have been traversed. /// ```ignore @@ -1000,23 +996,23 @@ pub trait BorrowedBinaryTreeNode<'a> /// \ /// 10 /// ``` - /// + /// fn dfs_preorder_iter(&'a self) -> impl TreeIterator { BorrowedBinaryDFSPreorderIterator::new(self) } /// This method retrieves an iterator that can be used to perform /// Depth First In Order searches of a tree. - /// + /// /// A Depth First In Order search is defined as: - /// - /// A tree traversal that involves depth-first searching a tree - /// from the left to the right. Given a tree of the following shape, - /// this traversal type would traverse + /// + /// A tree traversal that involves depth-first searching a tree + /// from the left to the right. Given a tree of the following shape, + /// this traversal type would traverse /// the elements in the order /// 3, 1, 4, 0, 5, 2, 7, 9, 10, 8, 6. - /// - /// In this traversal, each node will be traversed after its left + /// + /// In this traversal, each node will be traversed after its left /// child and before its right child. /// ```ignore /// 0 @@ -1033,22 +1029,22 @@ pub trait BorrowedBinaryTreeNode<'a> /// \ /// 10 /// ``` - /// + /// fn dfs_inorder_iter(&'a self) -> impl TreeIterator { BorrowedDFSInorderIterator::new(self) } /// This method retrieves an iterator that can be used to perform /// Depth First Postorder searches of a tree. - /// - /// A Depth First Postorder search (referred to as DFS Postorder) + /// + /// A Depth First Postorder search (referred to as DFS Postorder) /// is defined as: - /// - /// A tree traversal that involves depth-first searching a tree - /// from the bottom up. Given a tree of the following shape, this - /// traversal type would traverse the elements in the order + /// + /// A tree traversal that involves depth-first searching a tree + /// from the bottom up. Given a tree of the following shape, this + /// traversal type would traverse the elements in the order /// 3, 4, 1, 5, 10, 9, 8, 7, 6, 2, 0. - /// + /// /// In this traversal, each node will only be traversed after all /// of its children have been traversed. /// ```ignore @@ -1066,8 +1062,8 @@ pub trait BorrowedBinaryTreeNode<'a> /// \ /// 10 /// ``` - /// - /// This traversal type guarantees that getChildren() will only be + /// + /// This traversal type guarantees that getChildren() will only be /// called once per node of the tree. /// fn dfs_postorder_iter(&'a self) -> impl TreeIterator { @@ -1076,33 +1072,36 @@ pub trait BorrowedBinaryTreeNode<'a> } /// A tree node where getting its children borrows its value. -pub trait BorrowedTreeNode<'a> - where Self: Sized + 'a { - +pub trait BorrowedTreeNode<'a> +where + Self: Sized + 'a, +{ /// A reference to the value of each node in the tree. type BorrowedValue: Sized; - /// The type of iterator that can be used to iterate over each node's children + /// The type of iterator that can be used to iterate over each node's children /// collection. type BorrowedChildren: Iterator; - /// This method gets the value and children from this node, consuming it - /// in the process. The other methods of this trait assume that the 'Children' + /// This method gets the value and children from this node, consuming it + /// in the process. The other methods of this trait assume that the 'Children' /// list does not contain and circular references back to parent nodes. - fn get_value_and_children_iter(&'a self) -> (Self::BorrowedValue, Option); + fn get_value_and_children_iter( + &'a self, + ) -> (Self::BorrowedValue, Option); /// This method retrieves an iterator that can be used to perform - /// Breadth First (Queue - specifically VecDeque-based) searches of a tree. If performance is + /// Breadth First (Queue - specifically VecDeque-based) searches of a tree. If performance is /// not a serious concern, a Breadth First (iterative deepening) search /// (referred to as BFS in this library) should be preferred to make /// debugging easier. - /// + /// /// A Breadth First Search (BFS) is defined as: - /// - /// A tree traversal that involves breadth-first searching a tree - /// from the top down. Given a tree of the following shape, this - /// traversal type would traverse the elements in the order + /// + /// A tree traversal that involves breadth-first searching a tree + /// from the top down. Given a tree of the following shape, this + /// traversal type would traverse the elements in the order /// 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10. - /// + /// /// In this traversal, we scan each level of the tree from left to /// right before going down to the next level. /// ```ignore @@ -1120,23 +1119,23 @@ pub trait BorrowedTreeNode<'a> /// \ /// 10 /// ``` - /// + /// fn bfs_iter(&'a self) -> impl TreeIterator { BorrowedBFSIterator::new(self) } - /// This method retrieves an iterator that can be used to perform - /// Depth First Preorder searches of a tree. - /// - /// A Depth First Preorder search is defined as: - /// - /// A tree traversal that involves depth-first searching a tree - /// from the top down. Given a tree of the following shape, this - /// traversal type would traverse the elements in the order - /// 0, 1, 3, 4, 2, 5, 6, 7, 8, 9, 10. - /// - /// In this traversal, each node will only be traversed before any - /// of its children have been traversed. + /// This method retrieves an iterator that can be used to perform + /// Depth First Preorder searches of a tree. + /// + /// A Depth First Preorder search is defined as: + /// + /// A tree traversal that involves depth-first searching a tree + /// from the top down. Given a tree of the following shape, this + /// traversal type would traverse the elements in the order + /// 0, 1, 3, 4, 2, 5, 6, 7, 8, 9, 10. + /// + /// In this traversal, each node will only be traversed before any + /// of its children have been traversed. /// ```ignore /// 0 /// / \ @@ -1152,22 +1151,22 @@ pub trait BorrowedTreeNode<'a> /// \ /// 10 /// ``` - /// + /// fn dfs_preorder_iter(&'a self) -> impl TreeIterator { BorrowedDFSPreorderIterator::new(self) } /// This method retrieves an iterator that can be used to perform /// Depth First Postorder searches of a tree. - /// - /// A Depth First Postorder search (referred to as DFS Postorder) + /// + /// A Depth First Postorder search (referred to as DFS Postorder) /// is defined as: - /// - /// A tree traversal that involves depth-first searching a tree - /// from the bottom up. Given a tree of the following shape, this - /// traversal type would traverse the elements in the order + /// + /// A tree traversal that involves depth-first searching a tree + /// from the bottom up. Given a tree of the following shape, this + /// traversal type would traverse the elements in the order /// 3, 4, 1, 5, 10, 9, 8, 7, 6, 2, 0. - /// + /// /// In this traversal, each node will only be traversed after all /// of its children have been traversed. /// ```ignore @@ -1185,8 +1184,8 @@ pub trait BorrowedTreeNode<'a> /// \ /// 10 /// ``` - /// - /// This traversal type guarantees that getChildren() will only be + /// + /// This traversal type guarantees that getChildren() will only be /// called once per node of the tree. /// fn dfs_postorder_iter(&'a self) -> impl TreeIterator { @@ -1198,60 +1197,65 @@ impl OwnedTreeNode for TreeNode { type OwnedValue = T; type OwnedChildren = IntoIter; - /// This method gets the value and children from this node. The other - /// methods of this trait assume that the 'Children' list does not contain + /// This method gets the value and children from this node. The other + /// methods of this trait assume that the 'Children' list does not contain /// any circular references. If there are, an inifite loop will result. fn get_value_and_children(self) -> (Self::OwnedValue, Option) { ( - self.value, + self.value, match self.children { None => None, - Some(children) => Some(children.into_iter()) - } + Some(children) => Some(children.into_iter()), + }, ) } } -impl<'a, T> MutBorrowedTreeNode<'a> for TreeNode - where T: 'a { - +impl<'a, T> MutBorrowedTreeNode<'a> for TreeNode +where + T: 'a, +{ type MutBorrowedValue = &'a mut T; type MutBorrowedChildren = IterMut<'a, TreeNode>; - /// This method gets the value and children from this node. The other - /// methods of this trait assume that the 'Children' list does not contain + /// This method gets the value and children from this node. The other + /// methods of this trait assume that the 'Children' list does not contain /// any circular references. If there are, an inifite loop will result. - fn get_value_and_children_iter_mut(&'a mut self) -> (Self::MutBorrowedValue, Option) { + fn get_value_and_children_iter_mut( + &'a mut self, + ) -> (Self::MutBorrowedValue, Option) { ( &mut self.value, match &mut self.children { None => None, - Some(children) => Some(children.iter_mut()) - } + Some(children) => Some(children.iter_mut()), + }, ) } } -impl<'a, T> BorrowedTreeNode<'a> for TreeNode - where T: 'a { - +impl<'a, T> BorrowedTreeNode<'a> for TreeNode +where + T: 'a, +{ type BorrowedValue = &'a T; type BorrowedChildren = Iter<'a, TreeNode>; - /// This method gets the value and children from this node. The other - /// methods of this trait assume that the 'Children' list does not contain + /// This method gets the value and children from this node. The other + /// methods of this trait assume that the 'Children' list does not contain /// any circular references. If there are, an inifite loop will result. - fn get_value_and_children_iter(&'a self) -> (Self::BorrowedValue, Option) { + fn get_value_and_children_iter( + &'a self, + ) -> (Self::BorrowedValue, Option) { let children_iter = match &self.children { Some(vec) => Some(vec.iter()), - None => None + None => None, }; (&self.value, children_iter) } } impl OwnedBinaryTreeNode for BinaryTreeNode { - type OwnedValue = T; fn get_value_and_children_binary(self) -> (Self::OwnedValue, [Option; 2]) { @@ -1265,52 +1269,58 @@ impl OwnedBinaryTreeNode for BinaryTreeNode { match self.right { Some(boxed) => Some(*boxed), None => None, - } - ] + }, + ], ) } } -impl<'a, T> MutBorrowedBinaryTreeNode<'a> for BinaryTreeNode - where Self: 'a { - +impl<'a, T> MutBorrowedBinaryTreeNode<'a> for BinaryTreeNode +where + Self: 'a, +{ type MutBorrowedValue = &'a mut T; - fn get_value_and_children_binary_iter_mut(&'a mut self) -> (Self::MutBorrowedValue, [Option<&'a mut Self>; 2]) { + fn get_value_and_children_binary_iter_mut( + &'a mut self, + ) -> (Self::MutBorrowedValue, [Option<&'a mut Self>; 2]) { ( &mut self.value, [ match &mut self.left { Some(left) => Some(left.as_mut()), - None => None + None => None, }, match &mut self.right { Some(right) => Some(right.as_mut()), - None => None - } - ] + None => None, + }, + ], ) } } -impl<'a, T> BorrowedBinaryTreeNode<'a> for BinaryTreeNode - where Self: 'a { - +impl<'a, T> BorrowedBinaryTreeNode<'a> for BinaryTreeNode +where + Self: 'a, +{ type BorrowedValue = &'a T; - fn get_value_and_children_binary_iter(&'a self) -> (Self::BorrowedValue, [Option<&'a Self>; 2]) { + fn get_value_and_children_binary_iter( + &'a self, + ) -> (Self::BorrowedValue, [Option<&'a Self>; 2]) { ( &self.value, [ match &self.left { Some(left) => Some(left.as_ref()), - None => None + None => None, }, match &self.right { Some(right) => Some(right.as_ref()), - None => None - } - ] + None => None, + }, + ], ) } } @@ -1320,23 +1330,21 @@ fn opt_to_opt(opt: Option) -> Option { } #[cfg(test)] -pub (crate) mod tests { +pub(crate) mod tests { use super::*; use alloc::vec; #[cfg(test)] mod dfs_preorder_tests { - use crate::prelude::*; use super::{ - assert_len, - create_trees_for_testing, - create_binary_tree_for_testing, - get_expected_metadata_for_value + assert_len, create_binary_tree_for_testing, create_trees_for_testing, + get_expected_metadata_for_value, }; + use crate::prelude::*; use streaming_iterator::StreamingIterator; - pub (crate) fn get_expected_order_dfs_preorder() -> [usize; 11] { - [0,1,3,4,2,5,6,7,8,9,10] + pub(crate) fn get_expected_order_dfs_preorder() -> [usize; 11] { + [0, 1, 3, 4, 2, 5, 6, 7, 8, 9, 10] } #[test] @@ -1348,7 +1356,7 @@ pub (crate) mod tests { assert_eq!(expected[i], *value); } assert_len!(expected.len(), test_tree.dfs_preorder_iter()); - + for (i, value) in test_tree.dfs_preorder_iter_mut().enumerate() { assert_eq!(expected[i], *value); } @@ -1370,12 +1378,12 @@ pub (crate) mod tests { assert_eq!(expected[i], *value); } assert_len!(expected.len(), test_tree.dfs_preorder_iter()); - + for (i, value) in test_tree.dfs_preorder_iter_mut().enumerate() { assert_eq!(expected[i], *value); } assert_len!(expected.len(), test_tree.dfs_preorder_iter_mut()); - + for (i, value) in test_tree.clone().dfs_preorder().enumerate() { assert_eq!(expected[i], value); } @@ -1458,7 +1466,9 @@ pub (crate) mod tests { assert_eq!(expected.len(), i); let mut i = 0; - let mut iter_with_metadata = create_binary_tree_for_testing().dfs_preorder().attach_ancestors(); + let mut iter_with_metadata = create_binary_tree_for_testing() + .dfs_preorder() + .attach_ancestors(); while let Some(value) = iter_with_metadata.next() { assert_eq!(expected[i], value[value.len() - 1]); let expected = get_expected_metadata_for_value(value[value.len() - 1]); @@ -1470,19 +1480,15 @@ pub (crate) mod tests { assert_eq!(expected.len(), i); } } - + #[cfg(test)] mod dfs_inorder_tests { + use super::{assert_len, create_binary_tree_for_testing, get_expected_metadata_for_value}; use crate::prelude::*; - use super::{ - assert_len, - create_binary_tree_for_testing, - get_expected_metadata_for_value - }; - use streaming_iterator::StreamingIterator; + use streaming_iterator::StreamingIterator; - pub (crate) fn get_expected_order_dfs_inorder() -> [usize; 11] { - [3,1,4,0,5,2,7,9,10,8,6] + pub(crate) fn get_expected_order_dfs_inorder() -> [usize; 11] { + [3, 1, 4, 0, 5, 2, 7, 9, 10, 8, 6] } #[test] @@ -1504,7 +1510,7 @@ pub (crate) mod tests { assert_eq!(expected[i], value); } assert_len!(expected.len(), test_tree.dfs_inorder()); - } + } #[test] fn dfs_inorder_attach_ancestors_works() { @@ -1552,17 +1558,15 @@ pub (crate) mod tests { } mod dfs_postorder_tests { - use crate::prelude::*; use super::{ - assert_len, - create_trees_for_testing, - create_binary_tree_for_testing, - get_expected_metadata_for_value + assert_len, create_binary_tree_for_testing, create_trees_for_testing, + get_expected_metadata_for_value, }; - use streaming_iterator::StreamingIterator; + use crate::prelude::*; + use streaming_iterator::StreamingIterator; - pub (crate) fn get_expected_order_dfs_postorder() -> [usize; 11] { - [3,4,1,5,10,9,8,7,6,2,0] + pub(crate) fn get_expected_order_dfs_postorder() -> [usize; 11] { + [3, 4, 1, 5, 10, 9, 8, 7, 6, 2, 0] } #[test] @@ -1590,27 +1594,27 @@ pub (crate) mod tests { fn binary_dfs_postorder_has_correct_order() { let expected = get_expected_order_dfs_postorder(); let mut test_tree = create_binary_tree_for_testing(); - + for (i, value) in test_tree.dfs_postorder_iter().enumerate() { assert_eq!(expected[i], *value); } assert_len!(expected.len(), test_tree.dfs_postorder_iter()); - + for (i, value) in test_tree.dfs_postorder_iter_mut().enumerate() { assert_eq!(expected[i], *value); } assert_len!(expected.len(), test_tree.dfs_postorder_iter_mut()); - + for (i, value) in test_tree.clone().dfs_postorder().enumerate() { assert_eq!(expected[i], value); } assert_len!(expected.len(), test_tree.dfs_postorder()); } - + #[test] fn dfs_postorder_attach_ancestors_works() { let expected = get_expected_order_dfs_postorder(); - + for mut test_tree in create_trees_for_testing() { let mut i = 0; let mut iter_with_metadata = test_tree.dfs_postorder_iter().attach_ancestors(); @@ -1651,11 +1655,11 @@ pub (crate) mod tests { assert_eq!(expected.len(), i); } } - + #[test] fn binary_dfs_postorder_attach_ancestors_works() { let expected = get_expected_order_dfs_postorder(); - + let mut i = 0; let test_tree = create_binary_tree_for_testing(); let mut iter_with_metadata = test_tree.dfs_postorder_iter().attach_ancestors(); @@ -1668,7 +1672,7 @@ pub (crate) mod tests { i += 1; } assert_eq!(expected.len(), i); - + let mut i = 0; let mut test_tree = create_binary_tree_for_testing(); let mut iter_with_metadata = test_tree.dfs_postorder_iter_mut().attach_ancestors(); @@ -1681,9 +1685,11 @@ pub (crate) mod tests { i += 1; } assert_eq!(expected.len(), i); - + let mut i = 0; - let mut iter_with_metadata = create_binary_tree_for_testing().dfs_postorder().attach_ancestors(); + let mut iter_with_metadata = create_binary_tree_for_testing() + .dfs_postorder() + .attach_ancestors(); while let Some(value) = iter_with_metadata.next() { assert_eq!(expected[i], value[value.len() - 1]); let expected = get_expected_metadata_for_value(value[value.len() - 1]); @@ -1697,17 +1703,15 @@ pub (crate) mod tests { } mod bfs_tests { - use crate::prelude::*; use super::{ - assert_len, - create_trees_for_testing, - create_binary_tree_for_testing, - get_expected_metadata_for_value + assert_len, create_binary_tree_for_testing, create_trees_for_testing, + get_expected_metadata_for_value, }; - use streaming_iterator::StreamingIterator; + use crate::prelude::*; + use streaming_iterator::StreamingIterator; - pub (crate) fn get_expected_order_bfs() -> [usize; 11] { - [0,1,2,3,4,5,6,7,8,9,10] + pub(crate) fn get_expected_order_bfs() -> [usize; 11] { + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] } #[test] @@ -1796,11 +1800,11 @@ pub (crate) mod tests { } assert_len!(expected.len(), test_tree.bfs()); } - + #[test] fn binary_bfs_attach_ancestors_works() { let expected = get_expected_order_bfs(); - + let mut i = 0; let test_tree = create_binary_tree_for_testing(); let mut iter_with_metadata = test_tree.bfs_iter().attach_ancestors(); @@ -1813,7 +1817,7 @@ pub (crate) mod tests { i += 1; } assert_eq!(expected.len(), i); - + let mut i = 0; let mut test_tree = create_binary_tree_for_testing(); let mut iter_with_metadata = test_tree.bfs_iter_mut().attach_ancestors(); @@ -1826,7 +1830,7 @@ pub (crate) mod tests { i += 1; } assert_eq!(expected.len(), i); - + let mut i = 0; let mut iter_with_metadata = create_binary_tree_for_testing().bfs().attach_ancestors(); while let Some(value) = iter_with_metadata.next() { @@ -1842,38 +1846,50 @@ pub (crate) mod tests { } #[cfg(test)] - mod leaves_tests { + mod ancestors_leaves_tests { extern crate std; + use alloc::{string::ToString, vec}; use std::println; + use super::{assert_len, create_binary_tree_for_testing, create_trees_for_testing}; use crate::prelude::*; - use super::{ - assert_len, - create_trees_for_testing, - create_binary_tree_for_testing, - }; - fn get_expected_order_leaves() -> [usize; 4] { - [3,4,5,10] + fn get_expected_order_leaves() -> [Vec; 4] { + [ + vec![0, 1, 3], + vec![0, 1, 4], + vec![0, 2, 5], + vec![0, 2, 6, 7, 8, 9, 10], + ] } #[test] fn leaves_has_correct_order() { let expected = get_expected_order_leaves(); for mut test_tree in create_trees_for_testing() { - for borrowed_iter in get_borrowed_leaves_iters(&test_tree) { - for (i, value) in borrowed_iter.enumerate() { - assert_eq!(expected[i], *value); + for mut borrowed_iter in get_borrowed_leaves_iters(&test_tree) { + let mut i = 0; + while let Some(value) = borrowed_iter.next() { + assert!(expected[i].iter().eq(value.iter().map(|val| *val))); + i += 1; } } + let mut i = 0; for borrowed_iter in get_borrowed_leaves_iters(&test_tree) { - assert_len!(expected.len(), borrowed_iter); + assert_len!( + expected.len(), + borrowed_iter, + alloc::format!("Failure at index {}", i.to_string()) + ); + i += 1; } - for mut_borrowed_iter in get_mut_borrowed_leaves_iters(&mut test_tree) { - for (i, value) in mut_borrowed_iter.enumerate() { - assert_eq!(expected[i], *value); + for mut mut_borrowed_iter in get_mut_borrowed_leaves_iters(&mut test_tree) { + let mut i = 0; + while let Some(value) = mut_borrowed_iter.next() { + assert!(expected[i].iter().eq(value.iter().map(|val| &**val))); + i += 1; } } @@ -1881,9 +1897,11 @@ pub (crate) mod tests { assert_len!(expected.len(), mut_borrowed_iter); } - for owned_iter in get_owned_leaves_iters(test_tree.clone()) { - for (i, value) in owned_iter.enumerate() { - assert_eq!(expected[i], value); + for mut owned_iter in get_owned_leaves_iters(test_tree.clone()) { + let mut i = 0; + while let Some(value) = owned_iter.next() { + assert!(expected[i].iter().eq(value.iter())); + i += 1; } } @@ -1895,33 +1913,64 @@ pub (crate) mod tests { } } - fn get_borrowed_leaves_iters(test_tree: &TreeNode) -> impl Iterator + '_>> + '_ { + fn get_borrowed_leaves_iters( + test_tree: &TreeNode, + ) -> impl Iterator + '_>> + '_ { [ - Box::new(test_tree.dfs_preorder_iter().leaves()) as Box>, - Box::new(test_tree.dfs_postorder_iter().leaves()), - Box::new(test_tree.bfs_iter().leaves()), - ].into_iter() + Box::new(test_tree.dfs_preorder_iter().attach_ancestors().leaves()) + as Box>, + Box::new(test_tree.dfs_postorder_iter().attach_ancestors().leaves()), + Box::new(test_tree.bfs_iter().attach_ancestors().leaves()), + ] + .into_iter() } - fn get_mut_borrowed_leaves_iters(test_tree: &mut TreeNode) -> impl Iterator + '_>> + '_ { - // Rust doesn't like this, but we know that only 1 iterator will be accessed at a time - // and no reallocations will be done as we are doing a readonly test, + fn get_mut_borrowed_leaves_iters( + test_tree: &mut TreeNode, + ) -> impl Iterator + '_>> + '_ { + // Rust doesn't like this, but we know that only 1 iterator will be accessed at a time + // and no reallocations will be done as we are doing a readonly test, // so we are still within the "safe" rust system with only 1 active mutable reference. // This also makes the test much nicer to write. unsafe { [ - Box::new((*(test_tree as *mut TreeNode)).dfs_preorder_iter_mut().leaves()) as Box>, - Box::new((*(test_tree as *mut TreeNode)).dfs_postorder_iter_mut().leaves()), - Box::new((*(test_tree as *mut TreeNode)).bfs_iter_mut().leaves()), - ].into_iter() + Box::new( + (*(test_tree as *mut TreeNode)) + .dfs_preorder_iter_mut() + .attach_ancestors() + .leaves(), + ) as Box>, + Box::new( + (*(test_tree as *mut TreeNode)) + .dfs_postorder_iter_mut() + .attach_ancestors() + .leaves(), + ), + Box::new( + (*(test_tree as *mut TreeNode)) + .bfs_iter_mut() + .attach_ancestors() + .leaves(), + ), + ] + .into_iter() } } - fn get_owned_leaves_iters(test_tree: TreeNode) -> [Box>; 3] { + fn get_owned_leaves_iters( + test_tree: TreeNode, + ) -> [Box>; 3] { [ - Box::new(test_tree.clone().dfs_preorder().leaves()) as Box>, - Box::new(test_tree.clone().dfs_postorder().leaves()), - Box::new(test_tree.clone().bfs().leaves()) + Box::new(test_tree.clone().dfs_preorder().attach_ancestors().leaves()) + as Box>, + Box::new( + test_tree + .clone() + .dfs_postorder() + .attach_ancestors() + .leaves(), + ), + Box::new(test_tree.clone().bfs().attach_ancestors().leaves()), ] } @@ -1930,19 +1979,37 @@ pub (crate) mod tests { let expected = get_expected_order_leaves(); let mut test_tree = create_binary_tree_for_testing(); - for borrowed_iter in get_borrowed_leaves_binary_iters(&test_tree) { - for (i, value) in borrowed_iter.enumerate() { - assert_eq!(expected[i], *value); + for mut borrowed_iter in get_borrowed_leaves_binary_iters(&test_tree) { + let mut i = 0; + while let Some(value) = borrowed_iter.next() { + assert!(expected[i].iter().eq(value.iter().map(|val| *val))); + i += 1; } } + let mut results = Vec::new(); for borrowed_iter in get_borrowed_leaves_binary_iters(&test_tree) { - assert_len!(expected.len(), borrowed_iter); + let mut count = 0; + borrowed_iter.for_each(|_| count += 1); + results.push(count); } + println!("{:?}", results); - for mut_borrowed_iter in get_mut_borrowed_leaves_binary_iters(&mut test_tree) { - for (i, value) in mut_borrowed_iter.enumerate() { - assert_eq!(expected[i], *value); + let mut i = 0; + for borrowed_iter in get_borrowed_leaves_binary_iters(&test_tree) { + assert_len!( + expected.len(), + borrowed_iter, + alloc::format!("Failure at index {}", i.to_string()) + ); + i += 1; + } + + for mut mut_borrowed_iter in get_mut_borrowed_leaves_binary_iters(&mut test_tree) { + let mut i = 0; + while let Some(value) = mut_borrowed_iter.next() { + assert!(expected[i].iter().eq(value.iter().map(|val| &**val))); + i += 1; } } @@ -1950,9 +2017,11 @@ pub (crate) mod tests { assert_len!(expected.len(), mut_borrowed_iter); } - for owned_iter in get_owned_leaves_binary_iters(test_tree.clone()) { - for (i, value) in owned_iter.enumerate() { - assert_eq!(expected[i], value); + for mut owned_iter in get_owned_leaves_binary_iters(test_tree.clone()) { + let mut i = 0; + while let Some(value) = owned_iter.next() { + assert!(expected[i].iter().eq(value.iter())); + i += 1; } } @@ -1961,38 +2030,763 @@ pub (crate) mod tests { } } - fn get_borrowed_leaves_binary_iters(test_tree: &BinaryTreeNode) -> [Box + '_>; 4] { + fn get_borrowed_leaves_binary_iters( + test_tree: &BinaryTreeNode, + ) -> [Box + '_>; 4] { [ - Box::new(test_tree.dfs_preorder_iter().leaves()) as Box>, - Box::new(test_tree.dfs_inorder_iter().leaves()), - Box::new(test_tree.dfs_postorder_iter().leaves()), - Box::new(test_tree.bfs_iter().leaves()) + Box::new(test_tree.dfs_preorder_iter().attach_ancestors().leaves()) + as Box>, + Box::new(test_tree.dfs_inorder_iter().attach_ancestors().leaves()), + Box::new(test_tree.dfs_postorder_iter().attach_ancestors().leaves()), + Box::new(test_tree.bfs_iter().attach_ancestors().leaves()), ] } - fn get_mut_borrowed_leaves_binary_iters(test_tree: &mut BinaryTreeNode) -> impl Iterator + '_>> { + fn get_mut_borrowed_leaves_binary_iters( + test_tree: &mut BinaryTreeNode, + ) -> impl Iterator + '_>> { unsafe { [ - Box::new((*(test_tree as *mut BinaryTreeNode)).dfs_preorder_iter_mut().leaves()) as Box>, - Box::new((*(test_tree as *mut BinaryTreeNode)).dfs_inorder_iter_mut().leaves()), - Box::new((*(test_tree as *mut BinaryTreeNode)).dfs_postorder_iter_mut().leaves()), - Box::new((*(test_tree as *mut BinaryTreeNode)).bfs_iter_mut().leaves()), - ].into_iter() + Box::new( + (*(test_tree as *mut BinaryTreeNode)) + .dfs_preorder_iter_mut() + .attach_ancestors() + .leaves(), + ) as Box>, + Box::new( + (*(test_tree as *mut BinaryTreeNode)) + .dfs_inorder_iter_mut() + .attach_ancestors() + .leaves(), + ), + Box::new( + (*(test_tree as *mut BinaryTreeNode)) + .dfs_postorder_iter_mut() + .attach_ancestors() + .leaves(), + ), + Box::new( + (*(test_tree as *mut BinaryTreeNode)) + .bfs_iter_mut() + .attach_ancestors() + .leaves(), + ), + ] + .into_iter() } } - fn get_owned_leaves_binary_iters(test_tree: BinaryTreeNode) -> [Box>; 4] { + fn get_owned_leaves_binary_iters( + test_tree: BinaryTreeNode, + ) -> [Box>; 4] { [ - Box::new(test_tree.clone().dfs_preorder().leaves()) as Box>, - Box::new(test_tree.clone().dfs_inorder().leaves()), + Box::new(test_tree.clone().dfs_preorder().attach_ancestors().leaves()) + as Box>, + Box::new(test_tree.clone().dfs_inorder().attach_ancestors().leaves()), + Box::new( + test_tree + .clone() + .dfs_postorder() + .attach_ancestors() + .leaves(), + ), + Box::new(test_tree.clone().bfs().attach_ancestors().leaves()), + ] + } + + #[test] + fn dfs_preorder_transformation_can_happen_mid_traversal() { + let expected_dfs_preorder = + super::dfs_preorder_tests::get_expected_order_dfs_preorder(); + let expected_leaves = get_expected_order_leaves(); + for mut test_tree in create_trees_for_testing() { + // interrupt traversal at all points. + for _ in 0..expected_dfs_preorder.len() { + let mut preorder_iter = test_tree.dfs_preorder_iter().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = preorder_iter.next() { + if *value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut preorder_iter_leaves = preorder_iter.leaves(); + let mut i = 0; + while let Some(value) = preorder_iter_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter().map(|val| *val))); + i += 1; + } + drop(preorder_iter_leaves); + + let mut preorder_iter_mut = + test_tree.dfs_preorder_iter_mut().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = preorder_iter_mut.next() { + if *value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut preorder_iter_leaves = preorder_iter_mut.leaves(); + let mut i = 0; + while let Some(value) = preorder_iter_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter().map(|val| &**val))); + i += 1; + } + drop(preorder_iter_leaves); + + let mut preorder = test_tree.clone().dfs_preorder().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = preorder.next() { + if value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut preorder_iter_leaves = preorder.leaves(); + let mut i = 0; + while let Some(value) = preorder_iter_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter())); + i += 1; + } + } + } + } + + #[test] + fn dfs_postorder_transformation_can_happen_mid_traversal() { + let expected_dfs_postorder = + super::dfs_postorder_tests::get_expected_order_dfs_postorder(); + let expected_leaves = get_expected_order_leaves(); + for mut test_tree in create_trees_for_testing() { + // interrupt traversal at all points. + for _ in 0..expected_dfs_postorder.len() { + let mut postorder_iter = test_tree.dfs_postorder_iter().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = postorder_iter.next() { + // dont index outside the array! + if num_leaves_seen == expected_leaves.len() { + continue; + } + if *value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut postorder_iter_leaves = postorder_iter.leaves(); + let mut i = 0; + while let Some(value) = postorder_iter_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter().map(|val| *val))); + i += 1; + } + drop(postorder_iter_leaves); + + let mut postorder_iter_mut = + test_tree.dfs_postorder_iter_mut().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = postorder_iter_mut.next() { + // dont index outside the array! + if num_leaves_seen == expected_leaves.len() { + continue; + } + if *value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut postorder_iter_leaves = postorder_iter_mut.leaves(); + let mut i = 0; + while let Some(value) = postorder_iter_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter().map(|val| &**val))); + i += 1; + } + drop(postorder_iter_leaves); + + let mut postorder = test_tree.clone().dfs_postorder().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = postorder.next() { + // dont index outside the array! + if num_leaves_seen == expected_leaves.len() { + continue; + } + if value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut postorder_iter_leaves = postorder.leaves(); + let mut i = 0; + while let Some(value) = postorder_iter_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter())); + i += 1; + } + } + } + } + + #[test] + fn bfs_transformation_can_happen_mid_traversal() { + let expected_bfs = super::bfs_tests::get_expected_order_bfs(); + let expected_leaves = get_expected_order_leaves(); + for mut test_tree in create_trees_for_testing() { + // interrupt traversal at all points. + for _ in 0..expected_bfs.len() { + let mut bfs_iter = test_tree.bfs_iter().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = bfs_iter.next() { + if *value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut bfs_iter_leaves = bfs_iter.leaves(); + let mut i = 0; + while let Some(value) = bfs_iter_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter().map(|val| *val))); + i += 1; + } + drop(bfs_iter_leaves); + + let mut bfs_iter_mut = test_tree.bfs_iter_mut().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = bfs_iter_mut.next() { + if *value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut bfs_iter_mut_leaves = bfs_iter_mut.leaves(); + let mut i = 0; + while let Some(value) = bfs_iter_mut_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter().map(|val| &**val))); + i += 1; + } + drop(bfs_iter_mut_leaves); + + let mut bfs = test_tree.clone().bfs().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = bfs.next() { + if value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut bfs_leaves = bfs.leaves(); + let mut i = 0; + while let Some(value) = bfs_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter())); + i += 1; + } + } + } + } + + #[test] + fn dfs_preorder_binary_transformation_can_happen_mid_traversal() { + let expected_dfs_preorder = + super::dfs_preorder_tests::get_expected_order_dfs_preorder(); + let expected_leaves = get_expected_order_leaves(); + let mut test_tree = create_binary_tree_for_testing(); + // interrupt traversal at all points. + for _ in 0..expected_dfs_preorder.len() { + let mut preorder_iter = test_tree.dfs_preorder_iter().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = preorder_iter.next() { + if *value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut preorder_iter_leaves = preorder_iter.leaves(); + let mut i = 0; + while let Some(value) = preorder_iter_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter().map(|val| *val))); + i += 1; + } + drop(preorder_iter_leaves); + + let mut preorder_iter_mut = test_tree.dfs_preorder_iter_mut().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = preorder_iter_mut.next() { + if *value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut preorder_iter_leaves = preorder_iter_mut.leaves(); + let mut i = 0; + while let Some(value) = preorder_iter_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter().map(|val| &**val))); + i += 1; + } + drop(preorder_iter_leaves); + + let mut preorder = test_tree.clone().dfs_preorder().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = preorder.next() { + if value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut preorder_iter_leaves = preorder.leaves(); + let mut i = 0; + while let Some(value) = preorder_iter_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter())); + i += 1; + } + } + } + + #[test] + fn dfs_inorder_binary_transformation_can_happen_mid_traversal() { + let expected_dfs_inorder = super::dfs_inorder_tests::get_expected_order_dfs_inorder(); + let expected_leaves = get_expected_order_leaves(); + let mut test_tree = create_binary_tree_for_testing(); + // interrupt traversal at all points. + for _ in 0..expected_dfs_inorder.len() { + let mut inorder_iter = test_tree.dfs_inorder_iter().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = inorder_iter.next() { + // dont index outside the array! + if num_leaves_seen == expected_leaves.len() { + continue; + } + if *value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut inorder_iter_leaves = inorder_iter.leaves(); + let mut i = 0; + while let Some(value) = inorder_iter_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter().map(|val| *val))); + i += 1; + } + drop(inorder_iter_leaves); + + let mut inorder_iter_mut = test_tree.dfs_inorder_iter_mut().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = inorder_iter_mut.next() { + // dont index outside the array! + if num_leaves_seen == expected_leaves.len() { + continue; + } + if *value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut inorder_iter_leaves = inorder_iter_mut.leaves(); + let mut i = 0; + while let Some(value) = inorder_iter_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter().map(|val| &**val))); + i += 1; + } + drop(inorder_iter_leaves); + + let mut inorder = test_tree.clone().dfs_inorder().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = inorder.next() { + // dont index outside the array! + if num_leaves_seen == expected_leaves.len() { + continue; + } + if value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut inorder_iter_leaves = inorder.leaves(); + let mut i = 0; + while let Some(value) = inorder_iter_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter())); + i += 1; + } + } + } + + #[test] + fn dfs_postorder_binary_transformation_can_happen_mid_traversal() { + let expected_dfs_postorder = + super::dfs_postorder_tests::get_expected_order_dfs_postorder(); + let expected_leaves = get_expected_order_leaves(); + let mut test_tree = create_binary_tree_for_testing(); + // interrupt traversal at all points. + for _ in 0..expected_dfs_postorder.len() { + let mut postorder_iter = test_tree.dfs_postorder_iter().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = postorder_iter.next() { + // dont index outside the array! + if num_leaves_seen == expected_leaves.len() { + continue; + } + if *value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut postorder_iter_leaves = postorder_iter.leaves(); + let mut i = 0; + while let Some(value) = postorder_iter_leaves.next() { + // dont index outside the array! + if num_leaves_seen == expected_leaves.len() { + continue; + } + assert!(expected_leaves[i].iter().eq(value.iter().map(|val| *val))); + i += 1; + } + drop(postorder_iter_leaves); + + let mut postorder_iter_mut = test_tree.dfs_postorder_iter_mut().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = postorder_iter_mut.next() { + // dont index outside the array! + if num_leaves_seen == expected_leaves.len() { + continue; + } + if *value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut postorder_iter_leaves = postorder_iter_mut.leaves(); + let mut i = 0; + while let Some(value) = postorder_iter_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter().map(|val| &**val))); + i += 1; + } + drop(postorder_iter_leaves); + + let mut postorder = test_tree.clone().dfs_postorder().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = postorder.next() { + // dont index outside the array! + if num_leaves_seen == expected_leaves.len() { + continue; + } + if value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut postorder_iter_leaves = postorder.leaves(); + let mut i = 0; + while let Some(value) = postorder_iter_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter())); + i += 1; + } + } + } + + #[test] + fn bfs_binary_transformation_can_happen_mid_traversal() { + let expected_bfs = super::bfs_tests::get_expected_order_bfs(); + let expected_leaves = get_expected_order_leaves(); + let mut test_tree = create_binary_tree_for_testing(); + // interrupt traversal at all points. + for _ in 0..expected_bfs.len() { + let mut bfs_iter = test_tree.bfs_iter().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = bfs_iter.next() { + if *value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut bfs_iter_leaves = bfs_iter.leaves(); + let mut i = 0; + while let Some(value) = bfs_iter_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter().map(|val| *val))); + i += 1; + } + drop(bfs_iter_leaves); + + let mut bfs_iter_mut = test_tree.bfs_iter_mut().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = bfs_iter_mut.next() { + if *value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut bfs_iter_mut_leaves = bfs_iter_mut.leaves(); + let mut i = 0; + while let Some(value) = bfs_iter_mut_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter().map(|val| &**val))); + i += 1; + } + drop(bfs_iter_mut_leaves); + + let mut bfs = test_tree.clone().bfs().attach_ancestors(); + let mut num_leaves_seen = 0; + while let Some(value) = bfs.next() { + if value[value.len() - 1] + == expected_leaves[num_leaves_seen] + [expected_leaves[num_leaves_seen].len() - 1] + { + num_leaves_seen += 1; + } + } + + let mut bfs_leaves = bfs.leaves(); + let mut i = 0; + while let Some(value) = bfs_leaves.next() { + assert!(expected_leaves[i].iter().eq(value.iter())); + i += 1; + } + } + } + } + + #[cfg(test)] + mod leaves_tests { + extern crate std; + use std::println; + + use super::{assert_len, create_binary_tree_for_testing, create_trees_for_testing}; + use crate::prelude::*; + + fn get_expected_order_leaves() -> [usize; 4] { + [3, 4, 5, 10] + } + + #[test] + fn leaves_has_correct_order() { + let expected = get_expected_order_leaves(); + for mut test_tree in create_trees_for_testing() { + for borrowed_iter in get_borrowed_leaves_iters(&test_tree) { + for (i, value) in borrowed_iter.enumerate() { + assert_eq!(expected[i], *value); + } + } + + for borrowed_iter in get_borrowed_leaves_iters(&test_tree) { + assert_len!(expected.len(), borrowed_iter); + } + + for mut_borrowed_iter in get_mut_borrowed_leaves_iters(&mut test_tree) { + for (i, value) in mut_borrowed_iter.enumerate() { + assert_eq!(expected[i], *value); + } + } + + for mut_borrowed_iter in get_mut_borrowed_leaves_iters(&mut test_tree) { + assert_len!(expected.len(), mut_borrowed_iter); + } + + for owned_iter in get_owned_leaves_iters(test_tree.clone()) { + for (i, value) in owned_iter.enumerate() { + assert_eq!(expected[i], value); + } + } + + for owned_iter in get_owned_leaves_iters(test_tree) { + assert_len!(expected.len(), owned_iter); + } + + println!("finished first round"); + } + } + + fn get_borrowed_leaves_iters( + test_tree: &TreeNode, + ) -> impl Iterator + '_>> + '_ { + [ + Box::new(test_tree.dfs_preorder_iter().leaves()) as Box>, + Box::new(test_tree.dfs_postorder_iter().leaves()), + Box::new(test_tree.bfs_iter().leaves()), + ] + .into_iter() + } + + fn get_mut_borrowed_leaves_iters( + test_tree: &mut TreeNode, + ) -> impl Iterator + '_>> + '_ { + // Rust doesn't like this, but we know that only 1 iterator will be accessed at a time + // and no reallocations will be done as we are doing a readonly test, + // so we are still within the "safe" rust system with only 1 active mutable reference. + // This also makes the test much nicer to write. + unsafe { + [ + Box::new( + (*(test_tree as *mut TreeNode)) + .dfs_preorder_iter_mut() + .leaves(), + ) as Box>, + Box::new( + (*(test_tree as *mut TreeNode)) + .dfs_postorder_iter_mut() + .leaves(), + ), + Box::new((*(test_tree as *mut TreeNode)).bfs_iter_mut().leaves()), + ] + .into_iter() + } + } + + fn get_owned_leaves_iters( + test_tree: TreeNode, + ) -> [Box>; 3] { + [ + Box::new(test_tree.clone().dfs_preorder().leaves()) as Box>, Box::new(test_tree.clone().dfs_postorder().leaves()), - Box::new(test_tree.clone().bfs().leaves()) + Box::new(test_tree.clone().bfs().leaves()), + ] + } + + #[test] + fn binary_leaves_has_correct_order() { + let expected = get_expected_order_leaves(); + let mut test_tree = create_binary_tree_for_testing(); + + for borrowed_iter in get_borrowed_leaves_binary_iters(&test_tree) { + for (i, value) in borrowed_iter.enumerate() { + assert_eq!(expected[i], *value); + } + } + + for borrowed_iter in get_borrowed_leaves_binary_iters(&test_tree) { + assert_len!(expected.len(), borrowed_iter); + } + + for mut_borrowed_iter in get_mut_borrowed_leaves_binary_iters(&mut test_tree) { + for (i, value) in mut_borrowed_iter.enumerate() { + assert_eq!(expected[i], *value); + } + } + + for mut_borrowed_iter in get_mut_borrowed_leaves_binary_iters(&mut test_tree) { + assert_len!(expected.len(), mut_borrowed_iter); + } + + for owned_iter in get_owned_leaves_binary_iters(test_tree.clone()) { + for (i, value) in owned_iter.enumerate() { + assert_eq!(expected[i], value); + } + } + + for owned_iter in get_owned_leaves_binary_iters(test_tree) { + assert_len!(expected.len(), owned_iter); + } + } + + fn get_borrowed_leaves_binary_iters( + test_tree: &BinaryTreeNode, + ) -> [Box + '_>; 4] { + [ + Box::new(test_tree.dfs_preorder_iter().leaves()) as Box>, + Box::new(test_tree.dfs_inorder_iter().leaves()), + Box::new(test_tree.dfs_postorder_iter().leaves()), + Box::new(test_tree.bfs_iter().leaves()), + ] + } + + fn get_mut_borrowed_leaves_binary_iters( + test_tree: &mut BinaryTreeNode, + ) -> impl Iterator + '_>> { + unsafe { + [ + Box::new( + (*(test_tree as *mut BinaryTreeNode)) + .dfs_preorder_iter_mut() + .leaves(), + ) as Box>, + Box::new( + (*(test_tree as *mut BinaryTreeNode)) + .dfs_inorder_iter_mut() + .leaves(), + ), + Box::new( + (*(test_tree as *mut BinaryTreeNode)) + .dfs_postorder_iter_mut() + .leaves(), + ), + Box::new( + (*(test_tree as *mut BinaryTreeNode)) + .bfs_iter_mut() + .leaves(), + ), + ] + .into_iter() + } + } + + fn get_owned_leaves_binary_iters( + test_tree: BinaryTreeNode, + ) -> [Box>; 4] { + [ + Box::new(test_tree.clone().dfs_preorder().leaves()) as Box>, + Box::new(test_tree.clone().dfs_inorder().leaves()), + Box::new(test_tree.clone().dfs_postorder().leaves()), + Box::new(test_tree.clone().bfs().leaves()), ] } #[test] fn dfs_preorder_transformation_can_happen_mid_traversal() { - let expected_dfs_preorder = super::dfs_preorder_tests::get_expected_order_dfs_preorder(); + let expected_dfs_preorder = + super::dfs_preorder_tests::get_expected_order_dfs_preorder(); let expected_leaves = get_expected_order_leaves(); for mut test_tree in create_trees_for_testing() { // interrupt traversal at all points. @@ -2000,8 +2794,8 @@ pub (crate) mod tests { let mut preorder_iter = test_tree.dfs_preorder_iter(); let mut num_leaves_seen = 0; while let Some(value) = preorder_iter.next() { - if *value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if *value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2010,12 +2804,11 @@ pub (crate) mod tests { assert_eq!(expected_leaves[i + num_leaves_seen], *value); } - let mut preorder_iter_mut = test_tree.dfs_preorder_iter_mut(); let mut num_leaves_seen = 0; while let Some(value) = preorder_iter_mut.next() { - if *value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if *value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2024,12 +2817,11 @@ pub (crate) mod tests { assert_eq!(expected_leaves[i + num_leaves_seen], *value); } - let mut preorder = test_tree.clone().dfs_preorder(); let mut num_leaves_seen = 0; while let Some(value) = preorder.next() { - if value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2043,7 +2835,8 @@ pub (crate) mod tests { #[test] fn dfs_postorder_transformation_can_happen_mid_traversal() { - let expected_dfs_postorder = super::dfs_postorder_tests::get_expected_order_dfs_postorder(); + let expected_dfs_postorder = + super::dfs_postorder_tests::get_expected_order_dfs_postorder(); let expected_leaves = get_expected_order_leaves(); for mut test_tree in create_trees_for_testing() { // interrupt traversal at all points. @@ -2052,9 +2845,11 @@ pub (crate) mod tests { let mut num_leaves_seen = 0; while let Some(value) = postorder_iter.next() { // dont index outside the array! - if num_leaves_seen == expected_leaves.len() { continue; } - if *value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if num_leaves_seen == expected_leaves.len() { + continue; + } + if *value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2063,14 +2858,15 @@ pub (crate) mod tests { assert_eq!(expected_leaves[i + num_leaves_seen], *value); } - let mut postorder_iter_mut = test_tree.dfs_postorder_iter_mut(); let mut num_leaves_seen = 0; while let Some(value) = postorder_iter_mut.next() { // dont index outside the array! - if num_leaves_seen == expected_leaves.len() { continue; } - if *value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if num_leaves_seen == expected_leaves.len() { + continue; + } + if *value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2079,14 +2875,15 @@ pub (crate) mod tests { assert_eq!(expected_leaves[i + num_leaves_seen], *value); } - let mut postorder = test_tree.clone().dfs_postorder(); let mut num_leaves_seen = 0; while let Some(value) = postorder.next() { // dont index outside the array! - if num_leaves_seen == expected_leaves.len() { continue; } - if value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if num_leaves_seen == expected_leaves.len() { + continue; + } + if value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2108,8 +2905,8 @@ pub (crate) mod tests { let mut bfs_iter = test_tree.bfs_iter(); let mut num_leaves_seen = 0; while let Some(value) = bfs_iter.next() { - if *value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if *value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2118,12 +2915,11 @@ pub (crate) mod tests { assert_eq!(expected_leaves[i + num_leaves_seen], *value); } - let mut bfs_iter_mut = test_tree.bfs_iter_mut(); let mut num_leaves_seen = 0; while let Some(value) = bfs_iter_mut.next() { - if *value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if *value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2132,12 +2928,11 @@ pub (crate) mod tests { assert_eq!(expected_leaves[i + num_leaves_seen], *value); } - let mut bfs = test_tree.clone().bfs(); let mut num_leaves_seen = 0; while let Some(value) = bfs.next() { - if value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2151,16 +2946,17 @@ pub (crate) mod tests { #[test] fn dfs_preorder_binary_transformation_can_happen_mid_traversal() { - let expected_dfs_preorder = super::dfs_preorder_tests::get_expected_order_dfs_preorder(); + let expected_dfs_preorder = + super::dfs_preorder_tests::get_expected_order_dfs_preorder(); let expected_leaves = get_expected_order_leaves(); let mut test_tree = create_binary_tree_for_testing(); - // interrupt traversal at all points. + // interrupt traversal at all points. for _ in 0..expected_dfs_preorder.len() { let mut preorder_iter = test_tree.dfs_preorder_iter(); let mut num_leaves_seen = 0; while let Some(value) = preorder_iter.next() { - if *value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if *value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2169,12 +2965,11 @@ pub (crate) mod tests { assert_eq!(expected_leaves[i + num_leaves_seen], *value); } - let mut preorder_iter_mut = test_tree.dfs_preorder_iter_mut(); let mut num_leaves_seen = 0; while let Some(value) = preorder_iter_mut.next() { - if *value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if *value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2183,12 +2978,11 @@ pub (crate) mod tests { assert_eq!(expected_leaves[i + num_leaves_seen], *value); } - let mut preorder = test_tree.clone().dfs_preorder(); let mut num_leaves_seen = 0; while let Some(value) = preorder.next() { - if value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2210,9 +3004,11 @@ pub (crate) mod tests { let mut num_leaves_seen = 0; while let Some(value) = inorder_iter.next() { // dont index outside the array! - if num_leaves_seen == expected_leaves.len() { continue; } - if *value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if num_leaves_seen == expected_leaves.len() { + continue; + } + if *value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2221,14 +3017,15 @@ pub (crate) mod tests { assert_eq!(expected_leaves[i + num_leaves_seen], *value); } - let mut inorder_iter_mut = test_tree.dfs_inorder_iter_mut(); let mut num_leaves_seen = 0; while let Some(value) = inorder_iter_mut.next() { // dont index outside the array! - if num_leaves_seen == expected_leaves.len() { continue; } - if *value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if num_leaves_seen == expected_leaves.len() { + continue; + } + if *value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2237,14 +3034,15 @@ pub (crate) mod tests { assert_eq!(expected_leaves[i + num_leaves_seen], *value); } - let mut inorder = test_tree.clone().dfs_inorder(); let mut num_leaves_seen = 0; while let Some(value) = inorder.next() { // dont index outside the array! - if num_leaves_seen == expected_leaves.len() { continue; } - if value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if num_leaves_seen == expected_leaves.len() { + continue; + } + if value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2257,7 +3055,8 @@ pub (crate) mod tests { #[test] fn dfs_postorder_binary_transformation_can_happen_mid_traversal() { - let expected_dfs_postorder = super::dfs_postorder_tests::get_expected_order_dfs_postorder(); + let expected_dfs_postorder = + super::dfs_postorder_tests::get_expected_order_dfs_postorder(); let expected_leaves = get_expected_order_leaves(); let mut test_tree = create_binary_tree_for_testing(); // interrupt traversal at all points. @@ -2266,27 +3065,32 @@ pub (crate) mod tests { let mut num_leaves_seen = 0; while let Some(value) = postorder_iter.next() { // dont index outside the array! - if num_leaves_seen == expected_leaves.len() { continue; } - if *value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if num_leaves_seen == expected_leaves.len() { + continue; + } + if *value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } let postorder_iter_leaves = postorder_iter.leaves(); for (i, value) in postorder_iter_leaves.enumerate() { // dont index outside the array! - if num_leaves_seen == expected_leaves.len() { continue; } + if num_leaves_seen == expected_leaves.len() { + continue; + } assert_eq!(expected_leaves[i + num_leaves_seen], *value); } - let mut postorder_iter_mut = test_tree.dfs_postorder_iter_mut(); let mut num_leaves_seen = 0; while let Some(value) = postorder_iter_mut.next() { // dont index outside the array! - if num_leaves_seen == expected_leaves.len() { continue; } - if *value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if num_leaves_seen == expected_leaves.len() { + continue; + } + if *value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2295,14 +3099,15 @@ pub (crate) mod tests { assert_eq!(expected_leaves[i + num_leaves_seen], *value); } - let mut postorder = test_tree.clone().dfs_postorder(); let mut num_leaves_seen = 0; while let Some(value) = postorder.next() { // dont index outside the array! - if num_leaves_seen == expected_leaves.len() { continue; } - if value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if num_leaves_seen == expected_leaves.len() { + continue; + } + if value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2323,8 +3128,8 @@ pub (crate) mod tests { let mut bfs_iter = test_tree.bfs_iter(); let mut num_leaves_seen = 0; while let Some(value) = bfs_iter.next() { - if *value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if *value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2333,12 +3138,11 @@ pub (crate) mod tests { assert_eq!(expected_leaves[i + num_leaves_seen], *value); } - let mut bfs_iter_mut = test_tree.bfs_iter_mut(); let mut num_leaves_seen = 0; while let Some(value) = bfs_iter_mut.next() { - if *value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if *value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2347,12 +3151,11 @@ pub (crate) mod tests { assert_eq!(expected_leaves[i + num_leaves_seen], *value); } - let mut bfs = test_tree.clone().bfs(); let mut num_leaves_seen = 0; while let Some(value) = bfs.next() { - if value == expected_leaves[num_leaves_seen] { - num_leaves_seen += 1; + if value == expected_leaves[num_leaves_seen] { + num_leaves_seen += 1; } } @@ -2366,9 +3169,12 @@ pub (crate) mod tests { macro_rules! assert_len { ($expected: expr, $iter: expr) => { + assert_len!($expected, $iter, ""); + }; + ($expected: expr, $iter: expr, $message: expr) => { let mut count = 0; $iter.for_each(|_| count += 1); - assert_eq!($expected, count); + assert_eq!($expected, count, "{}", $message); }; } use assert_len; @@ -2393,11 +3199,13 @@ pub (crate) mod tests { fn create_trees_for_testing() -> Vec> { vec![ create_tree_for_testing(None), - create_tree_for_testing(Some(Vec::new())) + create_tree_for_testing(Some(Vec::new())), ] } - pub (crate) fn create_tree_for_testing(empty_children_list: Option>>) -> TreeNode { + pub(crate) fn create_tree_for_testing( + empty_children_list: Option>>, + ) -> TreeNode { TreeNode { value: 0, children: Some(vec![ @@ -2406,136 +3214,88 @@ pub (crate) mod tests { children: Some(vec![ TreeNode { value: 3, - children: empty_children_list.clone() + children: empty_children_list.clone(), }, TreeNode { value: 4, - children: empty_children_list.clone() - } - ]) + children: empty_children_list.clone(), + }, + ]), }, TreeNode { value: 2, children: Some(vec![ TreeNode { value: 5, - children: empty_children_list.clone() + children: empty_children_list.clone(), }, TreeNode { value: 6, - children: Some(vec![ - TreeNode { - value: 7, - children: Some(vec![ - TreeNode { - value: 8, - children: Some(vec![ - TreeNode { - value: 9, - children: Some(vec![ - TreeNode { - value: 10, - children: empty_children_list.clone() - } - ]) - } - ]) - } - ]) - } - ]) - } - ]) - } - ]) + children: Some(vec![TreeNode { + value: 7, + children: Some(vec![TreeNode { + value: 8, + children: Some(vec![TreeNode { + value: 9, + children: Some(vec![TreeNode { + value: 10, + children: empty_children_list.clone(), + }]), + }]), + }]), + }]), + }, + ]), + }, + ]), } } pub fn create_binary_tree_for_testing() -> BinaryTreeNode { - BinaryTreeNode { - value: 0, - left: Some( - Box::new( - BinaryTreeNode { - value: 1, - left: Some( - Box::new( - BinaryTreeNode { - value: 3, - left: None, - right: None, - } - ) - ), - right: Some( - Box::new( - BinaryTreeNode { - value: 4, - left: None, - right: None, - } - ) - ), - } - ) - ), - right: Some( - Box::new( - BinaryTreeNode { - value: 2, - left: Some( - Box::new( - BinaryTreeNode { - value: 5, + BinaryTreeNode { + value: 0, + left: Some(Box::new(BinaryTreeNode { + value: 1, + left: Some(Box::new(BinaryTreeNode { + value: 3, + left: None, + right: None, + })), + right: Some(Box::new(BinaryTreeNode { + value: 4, + left: None, + right: None, + })), + })), + right: Some(Box::new(BinaryTreeNode { + value: 2, + left: Some(Box::new(BinaryTreeNode { + value: 5, + left: None, + right: None, + })), + right: Some(Box::new(BinaryTreeNode { + value: 6, + left: Some(Box::new(BinaryTreeNode { + value: 7, + left: None, + right: Some(Box::new(BinaryTreeNode { + value: 8, + left: Some(Box::new(BinaryTreeNode { + value: 9, + left: None, + right: Some(Box::new(BinaryTreeNode { + value: 10, left: None, right: None, - } - ) - ), - right: Some( - Box::new( - BinaryTreeNode { - value: 6, - left: Some( - Box::new( - BinaryTreeNode { - value: 7, - left: None, - right: Some( - Box::new( - BinaryTreeNode { - value: 8, - left: Some( - Box::new( - BinaryTreeNode { - value: 9, - left: None, - right: Some( - Box::new( - BinaryTreeNode { - value: 10, - left: None, - right: None - } - ) - ) - } - ) - ), - right: None - } - ) - ) - } - ) - ), - right: None, - } - ) - ) - } - ) - ) + })), + })), + right: None, + })), + })), + right: None, + })), + })), } } -} \ No newline at end of file +}