Skip to content

Make NodeID generic to allow users to "tag" different tree structures #49

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
m-peeler wants to merge 4 commits into
base: master
Choose a base branch
from
Open

Make NodeID generic to allow users to "tag" different tree structures #49

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
3570303
Added ID Tagging Capabilities
m-peeler Jan 17, 2026
6e2761d
Fixes to Edge enum
m-peeler Jan 18, 2026
3681ec6
Added ID Tagging Capabilities
m-peeler Jan 17, 2026
23c8d99
Merge branch 'master' of https://github.com/m-peeler/tagged-ego-tree
m-peeler Jan 18, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
148 changes: 74 additions & 74 deletions src/iter.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,14 +2,14 @@ use std::iter::FusedIterator;
use std::ops::Range;
use std::{slice, vec};

use crate::{Node, NodeId, NodeRef, Tree};
use crate::{ID, Node, NodeId, NodeRef, Tree};

/// Iterator that moves out of a tree in insert order.
#[derive(Debug)]
pub struct IntoIter<T>(vec::IntoIter<Node<T>>);
impl<T> ExactSizeIterator for IntoIter<T> {}
impl<T> FusedIterator for IntoIter<T> {}
impl<T> Iterator for IntoIter<T> {
pub struct IntoIter<T, I: ID = NodeId>(vec::IntoIter<Node<T, I>>);
impl<T, I: ID> ExactSizeIterator for IntoIter<T, I> {}
impl<T, I: ID> FusedIterator for IntoIter<T, I> {}
impl<T, I: ID> Iterator for IntoIter<T, I> {
type Item = T;
fn next(&mut self) -> Option<Self::Item> {
self.0.next().map(|node| node.value)
Expand All @@ -18,23 +18,23 @@ impl<T> Iterator for IntoIter<T> {
self.0.size_hint()
}
}
impl<T> DoubleEndedIterator for IntoIter<T> {
impl<T, I: ID> DoubleEndedIterator for IntoIter<T, I> {
fn next_back(&mut self) -> Option<Self::Item> {
self.0.next_back().map(|node| node.value)
}
}

/// Iterator over values in insert order.
#[derive(Debug)]
pub struct Values<'a, T: 'a>(slice::Iter<'a, Node<T>>);
impl<'a, T: 'a> Clone for Values<'a, T> {
pub struct Values<'a, T: 'a, I: ID = NodeId>(slice::Iter<'a, Node<T, I>>);
impl<'a, T: 'a, I: ID> Clone for Values<'a, T, I> {
fn clone(&self) -> Self {
Values(self.0.clone())
}
}
impl<'a, T: 'a> ExactSizeIterator for Values<'a, T> {}
impl<'a, T: 'a> FusedIterator for Values<'a, T> {}
impl<'a, T: 'a> Iterator for Values<'a, T> {
impl<'a, T: 'a, I: ID> ExactSizeIterator for Values<'a, T, I> {}
impl<'a, T: 'a, I: ID> FusedIterator for Values<'a, T, I> {}
impl<'a, T: 'a, I: ID> Iterator for Values<'a, T, I> {
type Item = &'a T;
fn next(&mut self) -> Option<Self::Item> {
self.0.next().map(|node| &node.value)
Expand All @@ -43,18 +43,18 @@ impl<'a, T: 'a> Iterator for Values<'a, T> {
self.0.size_hint()
}
}
impl<'a, T: 'a> DoubleEndedIterator for Values<'a, T> {
impl<'a, T: 'a, I: ID> DoubleEndedIterator for Values<'a, T, I> {
fn next_back(&mut self) -> Option<Self::Item> {
self.0.next_back().map(|node| &node.value)
}
}

/// Mutable iterator over values in insert order.
#[derive(Debug)]
pub struct ValuesMut<'a, T: 'a>(slice::IterMut<'a, Node<T>>);
impl<'a, T: 'a> ExactSizeIterator for ValuesMut<'a, T> {}
impl<'a, T: 'a> FusedIterator for ValuesMut<'a, T> {}
impl<'a, T: 'a> Iterator for ValuesMut<'a, T> {
pub struct ValuesMut<'a, T: 'a, I: ID = NodeId>(slice::IterMut<'a, Node<T, I>>);
impl<'a, T: 'a, I: ID> ExactSizeIterator for ValuesMut<'a, T, I> {}
impl<'a, T: 'a, I: ID> FusedIterator for ValuesMut<'a, T, I> {}
impl<'a, T: 'a, I: ID> Iterator for ValuesMut<'a, T, I> {
type Item = &'a mut T;
fn next(&mut self) -> Option<Self::Item> {
self.0.next().map(|node| &mut node.value)
Expand All @@ -63,68 +63,68 @@ impl<'a, T: 'a> Iterator for ValuesMut<'a, T> {
self.0.size_hint()
}
}
impl<'a, T: 'a> DoubleEndedIterator for ValuesMut<'a, T> {
impl<'a, T: 'a, I: ID> DoubleEndedIterator for ValuesMut<'a, T, I> {
fn next_back(&mut self) -> Option<Self::Item> {
self.0.next_back().map(|node| &mut node.value)
}
}

/// Iterator over nodes in insert order.
#[derive(Debug)]
pub struct Nodes<'a, T: 'a> {
tree: &'a Tree<T>,
pub struct Nodes<'a, T: 'a, I: ID = NodeId> {
tree: &'a Tree<T, I>,
iter: Range<usize>,
}
impl<'a, T: 'a> Clone for Nodes<'a, T> {
impl<'a, T: 'a, I: ID> Clone for Nodes<'a, T, I> {
fn clone(&self) -> Self {
Self {
tree: self.tree,
iter: self.iter.clone(),
}
}
}
impl<'a, T: 'a> ExactSizeIterator for Nodes<'a, T> {}
impl<'a, T: 'a> FusedIterator for Nodes<'a, T> {}
impl<'a, T: 'a> Iterator for Nodes<'a, T> {
type Item = NodeRef<'a, T>;
impl<'a, T: 'a, I: ID> ExactSizeIterator for Nodes<'a, T, I> {}
impl<'a, T: 'a, I: ID> FusedIterator for Nodes<'a, T, I> {}
impl<'a, T: 'a, I: ID> Iterator for Nodes<'a, T, I> {
type Item = NodeRef<'a, T, I>;
fn next(&mut self) -> Option<Self::Item> {
self.iter
.next()
.map(|i| unsafe { self.tree.get_unchecked(NodeId::from_index(i)) })
.map(|i| unsafe { self.tree.get_unchecked(I::from_index(i)) })
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
impl<'a, T: 'a> DoubleEndedIterator for Nodes<'a, T> {
impl<'a, T: 'a, I: ID> DoubleEndedIterator for Nodes<'a, T, I> {
fn next_back(&mut self) -> Option<Self::Item> {
self.iter
.next_back()
.map(|i| unsafe { self.tree.get_unchecked(NodeId::from_index(i)) })
.map(|i| unsafe { self.tree.get_unchecked(I::from_index(i)) })
}
}

impl<T> IntoIterator for Tree<T> {
impl<T, I: ID> IntoIterator for Tree<T, I> {
type Item = T;
type IntoIter = IntoIter<T>;
type IntoIter = IntoIter<T, I>;
fn into_iter(self) -> Self::IntoIter {
IntoIter(self.vec.into_iter())
}
}

impl<T> Tree<T> {
impl<T, I: ID> Tree<T, I> {
/// Returns an iterator over values in insert order.
pub fn values(&self) -> Values<'_, T> {
pub fn values(&self) -> Values<'_, T, I> {
Values(self.vec.iter())
}

/// Returns a mutable iterator over values in insert order.
pub fn values_mut(&mut self) -> ValuesMut<'_, T> {
pub fn values_mut(&mut self) -> ValuesMut<'_, T, I> {
ValuesMut(self.vec.iter_mut())
}

/// Returns an iterator over nodes in insert order.
pub fn nodes(&self) -> Nodes<'_, T> {
pub fn nodes(&self) -> Nodes<'_, T, I> {
Nodes {
tree: self,
iter: 0..self.vec.len(),
Expand All @@ -137,15 +137,15 @@ macro_rules! axis_iterators {
$(
#[$m]
#[derive(Debug)]
pub struct $i<'a, T: 'a>(Option<NodeRef<'a, T>>);
impl<'a, T: 'a> Clone for $i<'a, T> {
pub struct $i<'a, T: 'a, I: ID = NodeId>(Option<NodeRef<'a, T, I>>);
impl<'a, T: 'a, I: ID> Clone for $i<'a, T, I> {
fn clone(&self) -> Self {
$i(self.0)
}
}
impl<'a, T: 'a> FusedIterator for $i<'a, T> {}
impl<'a, T: 'a> Iterator for $i<'a, T> {
type Item = NodeRef<'a, T>;
impl<'a, T: 'a, I: ID> FusedIterator for $i<'a, T, I> {}
impl<'a, T: 'a, I: ID> Iterator for $i<'a, T, I> {
type Item = NodeRef<'a, T, I>;
fn next(&mut self) -> Option<Self::Item> {
let node = self.0.take();
self.0 = node.as_ref().and_then($f);
Expand Down Expand Up @@ -175,21 +175,21 @@ axis_iterators! {

/// Iterator over children.
#[derive(Debug)]
pub struct Children<'a, T: 'a> {
front: Option<NodeRef<'a, T>>,
back: Option<NodeRef<'a, T>>,
pub struct Children<'a, T: 'a, I: ID = NodeId> {
front: Option<NodeRef<'a, T, I>>,
back: Option<NodeRef<'a, T, I>>,
}
impl<'a, T: 'a> Clone for Children<'a, T> {
impl<'a, T: 'a, I: ID> Clone for Children<'a, T, I> {
fn clone(&self) -> Self {
Self {
front: self.front,
back: self.back,
}
}
}
impl<'a, T: 'a> FusedIterator for Children<'a, T> {}
impl<'a, T: 'a> Iterator for Children<'a, T> {
type Item = NodeRef<'a, T>;
impl<'a, T: 'a, I: ID> FusedIterator for Children<'a, T, I> {}
impl<'a, T: 'a, I: ID> Iterator for Children<'a, T, I> {
type Item = NodeRef<'a, T, I>;
fn next(&mut self) -> Option<Self::Item> {
if self.front == self.back {
let node = self.front.take();
Expand All @@ -202,7 +202,7 @@ impl<'a, T: 'a> Iterator for Children<'a, T> {
}
}
}
impl<'a, T: 'a> DoubleEndedIterator for Children<'a, T> {
impl<'a, T: 'a, I: ID> DoubleEndedIterator for Children<'a, T, I> {
fn next_back(&mut self) -> Option<Self::Item> {
if self.back == self.front {
let node = self.back.take();
Expand All @@ -218,20 +218,20 @@ impl<'a, T: 'a> DoubleEndedIterator for Children<'a, T> {

/// Open or close edge of a node.
#[derive(Debug)]
pub enum Edge<'a, T: 'a> {
pub enum Edge<'a, T: 'a, I: ID> {
/// Open.
Open(NodeRef<'a, T>),
Open(NodeRef<'a, T, I>),
/// Close.
Close(NodeRef<'a, T>),
Close(NodeRef<'a, T, I>),
}
impl<'a, T: 'a> Copy for Edge<'a, T> {}
impl<'a, T: 'a> Clone for Edge<'a, T> {
impl<'a, T: 'a, I: ID> Copy for Edge<'a, T, I> {}
impl<'a, T: 'a, I: ID> Clone for Edge<'a, T, I> {
fn clone(&self) -> Self {
*self
}
}
impl<'a, T: 'a> Eq for Edge<'a, T> {}
impl<'a, T: 'a> PartialEq for Edge<'a, T> {
impl<'a, T: 'a, I: ID> Eq for Edge<'a, T, I> {}
impl<'a, T: 'a, I: ID> PartialEq for Edge<'a, T, I> {
fn eq(&self, other: &Self) -> bool {
match (*self, *other) {
(Edge::Open(a), Edge::Open(b)) | (Edge::Close(a), Edge::Close(b)) => a == b,
Expand All @@ -242,21 +242,21 @@ impl<'a, T: 'a> PartialEq for Edge<'a, T> {

/// Iterator which traverses a subtree.
#[derive(Debug)]
pub struct Traverse<'a, T: 'a> {
root: Option<NodeRef<'a, T>>,
edge: Option<Edge<'a, T>>,
pub struct Traverse<'a, T: 'a, I: ID = NodeId> {
root: Option<NodeRef<'a, T, I>>,
edge: Option<Edge<'a, T, I>>,
}
impl<'a, T: 'a> Clone for Traverse<'a, T> {
impl<'a, T: 'a, I: ID> Clone for Traverse<'a, T, I> {
fn clone(&self) -> Self {
Self {
root: self.root,
edge: self.edge,
}
}
}
impl<'a, T: 'a> FusedIterator for Traverse<'a, T> {}
impl<'a, T: 'a> Iterator for Traverse<'a, T> {
type Item = Edge<'a, T>;
impl<'a, T: 'a, I: ID> FusedIterator for Traverse<'a, T, I> {}
impl<'a, T: 'a, I: ID> Iterator for Traverse<'a, T, I> {
type Item = Edge<'a, T, I>;
fn next(&mut self) -> Option<Self::Item> {
match self.edge {
None => {
Expand Down Expand Up @@ -288,15 +288,15 @@ impl<'a, T: 'a> Iterator for Traverse<'a, T> {

/// Iterator over a node and its descendants.
#[derive(Debug)]
pub struct Descendants<'a, T: 'a>(Traverse<'a, T>);
impl<'a, T: 'a> Clone for Descendants<'a, T> {
pub struct Descendants<'a, T: 'a, I: ID = NodeId>(Traverse<'a, T, I>);
impl<'a, T: 'a, I: ID> Clone for Descendants<'a, T, I> {
fn clone(&self) -> Self {
Descendants(self.0.clone())
}
}
impl<'a, T: 'a> FusedIterator for Descendants<'a, T> {}
impl<'a, T: 'a> Iterator for Descendants<'a, T> {
type Item = NodeRef<'a, T>;
impl<'a, T: 'a, I: ID> FusedIterator for Descendants<'a, T, I> {}
impl<'a, T: 'a, I: ID> Iterator for Descendants<'a, T, I> {
type Item = NodeRef<'a, T, I>;
fn next(&mut self) -> Option<Self::Item> {
for edge in &mut self.0 {
if let Edge::Open(node) = edge {
Expand All @@ -307,50 +307,50 @@ impl<'a, T: 'a> Iterator for Descendants<'a, T> {
}
}

impl<'a, T: 'a> NodeRef<'a, T> {
impl<'a, T: 'a, I: ID> NodeRef<'a, T, I> {
/// Returns an iterator over ancestors.
pub fn ancestors(&self) -> Ancestors<'a, T> {
pub fn ancestors(&self) -> Ancestors<'a, T, I> {
Ancestors(self.parent())
}

/// Returns an iterator over previous siblings.
pub fn prev_siblings(&self) -> PrevSiblings<'a, T> {
pub fn prev_siblings(&self) -> PrevSiblings<'a, T, I> {
PrevSiblings(self.prev_sibling())
}

/// Returns an iterator over next siblings.
pub fn next_siblings(&self) -> NextSiblings<'a, T> {
pub fn next_siblings(&self) -> NextSiblings<'a, T, I> {
NextSiblings(self.next_sibling())
}

/// Returns an iterator over first children.
pub fn first_children(&self) -> FirstChildren<'a, T> {
pub fn first_children(&self) -> FirstChildren<'a, T, I> {
FirstChildren(self.first_child())
}

/// Returns an iterator over last children.
pub fn last_children(&self) -> LastChildren<'a, T> {
pub fn last_children(&self) -> LastChildren<'a, T, I> {
LastChildren(self.last_child())
}

/// Returns an iterator over children.
pub fn children(&self) -> Children<'a, T> {
pub fn children(&self) -> Children<'a, T, I> {
Children {
front: self.first_child(),
back: self.last_child(),
}
}

/// Returns an iterator which traverses the subtree starting at this node.
pub fn traverse(&self) -> Traverse<'a, T> {
pub fn traverse(&self) -> Traverse<'a, T, I> {
Traverse {
root: Some(*self),
edge: None,
}
}

/// Returns an iterator over this node and its descendants.
pub fn descendants(&self) -> Descendants<'a, T> {
pub fn descendants(&self) -> Descendants<'a, T, I> {
Descendants(self.traverse())
}
}
Loading