Set up a tree container that allows for some certain traversals #79

Merged
savanni merged 6 commits from tree-traversals into main 2023-10-25 03:13:39 +00:00
1 changed files with 30 additions and 14 deletions
Showing only changes of commit 2ceccbf38d - Show all commits

View File

@ -3,21 +3,25 @@
//!
//! This surely already exists. I am created it to test my own ability to do things in Rust.
use std::{cell::RefCell, collections::VecDeque, rc::Rc};
use std::{
cell::{Ref, RefCell},
collections::VecDeque,
rc::Rc,
};
#[derive(Debug)]
pub enum Tree<T: Clone> {
pub enum Tree<T> {
Empty,
Root(Node<T>),
}
impl<T: Clone> Default for Tree<T> {
impl<T> Default for Tree<T> {
fn default() -> Self {
Tree::Empty
}
}
impl<T: Clone> Tree<T> {
impl<T> Tree<T> {
pub fn set_value(&mut self, value: T) {
*self = Tree::Root(Node::new(value));
}
@ -41,7 +45,7 @@ impl<T: Clone> Tree<T> {
return Some(node.clone());
}
for child in node.children() {
for child in node.children().iter() {
queue.push_back(child.clone())
}
}
@ -54,16 +58,25 @@ impl<T: Clone> Tree<T> {
// make the visible objects mutable.
//
// This feels like cheating the type system.
#[derive(Clone, Debug)]
pub struct Node<T: Clone>(Rc<RefCell<Node_<T>>>);
//
// However, since I've moved the RefCell inside of the node, I can borrow the node multiple times
// in a traversal function and I can make changes to nodes that I find.
#[derive(Debug)]
pub struct Node<T>(Rc<RefCell<Node_<T>>>);
impl<T> Clone for Node<T> {
fn clone(&self) -> Self {
Node(Rc::clone(&self.0))
}
}
#[derive(Debug)]
struct Node_<T: Clone> {
struct Node_<T> {
value: T,
children: Vec<Node<T>>,
}
impl<T: Clone> Node<T> {
impl<T> Node<T> {
pub fn new(value: T) -> Self {
Self(Rc::new(RefCell::new(Node_ {
value,
@ -71,12 +84,15 @@ impl<T: Clone> Node<T> {
})))
}
pub fn value<'a>(&'a self) -> T {
self.0.borrow().value.clone()
// I am copying the value because I don't have a mechanism for keeping the borrow ref active.
// My next step is to figure out how to keep the borrow ref active so that I don't have to
// clone the item. Then I could drop the Clone constraint.
pub fn value<'a>(&'a self) -> Ref<T> {
Ref::map(self.0.borrow(), |v| &v.value)
}
pub fn children<'a>(&'a self) -> Vec<Node<T>> {
self.0.borrow().children.clone()
pub fn children<'a>(&'a self) -> Ref<Vec<Node<T>>> {
Ref::map(self.0.borrow(), |v| &v.children)
}
pub fn add_child_node(&self, child: Node<T>) {
@ -110,7 +126,7 @@ mod tests {
let n = Node::new(15);
n.add_child_value(20);
assert_eq!(n.value(), 15);
assert_eq!(*n.value(), 15);
// assert_eq!(n.children(), vec![Rc::new(RefCell::new(Node::new(20)))]);
}
}