I think I actually have a good foundation for a tree here.

src/day04/utilities.rs

@@ -14,10 +14,6 @@ impl Range {
         }
     }
 
-    pub fn calc_size(&self) -> u16 {
-        self.start.abs_diff(self.end)
-    }
-
     pub fn any_overlap(&self, other: &Self) -> bool {
         self.start <= other.end && self.end >= other.start
     }
@@ -31,14 +27,6 @@ impl Range {
     pub fn complete_overlap(&self, other: &Self) -> bool {
         self.calc_overlap(other) == *self || self.calc_overlap(other) == *other
     }
-
-    pub fn start(&self) -> u16 {
-        self.start
-    }
-
-    pub fn end(&self) -> u16 {
-        self.end
-    }
 }
 
 static PARSE_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"^(\d+)-(\d+),(\d+)-(\d+)").unwrap());

src/day07/fileTree.rs

@@ -1,21 +0,0 @@
-use std::{rc::{Weak, Rc}, cell::RefCell};
-
-#[derive(Debug)]
-pub struct Dir {
-    parent: Option<Weak<RefCell<Dir>>>,
-    name: String,
-    children: Vec<Rc<RefCell<FileOrDir>>>
-}
-
-#[derive(Debug)]
-pub struct File{
-    dir: Weak<RefCell<Dir>>,
-    size: usize,
-    name: String
-}
-
-#[derive(Debug)]
-pub enum FileOrDir{
-    File(File),
-    Dir(Dir),
-}

src/day07/file_tree.rs

@@ -0,0 +1,87 @@
+#![allow(unused)]
+use std::{
+    cell::RefCell,
+    ops::Deref,
+    rc::{Rc, Weak},
+};
+
+// #[derive(Debug)]
+// pub struct NodeRef(Rc<RefCell<Node>>);
+
+#[derive(Debug)]
+pub struct FileRef(Rc<RefCell<File>>);
+
+#[derive(Debug)]
+pub struct DirRef(Rc<RefCell<Dir>>);
+#[derive(Debug)]
+pub struct WeakDirRef(Weak<RefCell<Dir>>);
+
+#[derive(Debug)]
+pub enum Node {
+    Dir(DirRef),
+    File(FileRef),
+}
+
+#[derive(Debug)]
+pub struct File {
+    parent: WeakDirRef,
+    pub name: String,
+    pub size: usize,
+}
+
+#[derive(Debug, Default)]
+pub struct Dir {
+    parent: Option<WeakDirRef>,
+    pub name: String,
+    children: Vec<Node>,
+}
+
+impl DirRef {
+    //impling it on the ref makes the recursion a bit easier.
+    fn total_size(&self) -> usize {
+        self.0
+            .borrow()
+            .deref()
+            .children
+            .iter()
+            .map(|f| match f {
+                Node::Dir(dir) => dir.total_size(),
+                Node::File(file) => file.0.borrow().size,
+            })
+            .sum()
+    }
+    fn new(name: String) -> Self {
+        DirRef(Rc::new(RefCell::new(Dir {
+            parent: None,
+            name,
+            children: Vec::new(),
+        })))
+    }
+
+    //needs to be impled on the ref because of the need to get a weak backreference to self.
+    fn add(&self, node: Node) {
+        match node {
+            Node::Dir(ref dir) => {
+                dir.0.borrow_mut().parent = Some(WeakDirRef(Rc::downgrade(&self.0)))
+            }
+            Node::File(ref file) => file.0.borrow_mut().parent = WeakDirRef(Rc::downgrade(&self.0)),
+        }
+        self.0.borrow_mut().children.push(node);
+    }
+}
+
+impl File {
+    fn get_parent(&self)-> &WeakDirRef {
+        &self.parent
+    }
+}
+
+impl Dir {
+    fn get_children(&self) -> &[Node] {
+        &self.children
+    }
+
+    fn get_parent(&self) -> &Option<WeakDirRef> {
+        &self.parent
+    }
+}

src/day07/parser.rs

@@ -1,4 +1,5 @@
-use crate::fileTree::*;
+#![allow(unused)]
+use crate::file_tree::*;
 use once_cell::sync::Lazy;
 use regex::Regex;
 

src/day07/part1.rs

@@ -1,4 +1,5 @@
-use crate::fileTree::*;
+#![allow(unused)]
+use crate::file_tree::*;
 use crate::parser::*;
 
 pub fn part1() -> usize {

src/day07/part2.rs

@@ -1,4 +1,5 @@
-use crate::fileTree::*;
+#![allow(unused)]
+use crate::file_tree::*;
 use crate::parser::*;
 
 pub fn part2() -> usize {

src/day07/solve.rs

@@ -1,11 +1,12 @@
+#![allow(unused)]
 mod part1;
 mod part2;
 mod parser;
-mod fileTree;
+mod file_tree;
 
 fn main() {
-    let _input = include_str!("./input.txt");
+    let input = include_str!("./input.txt");
-    let _structured_input = parser::parse(_input);
+    let structured_input = parser::parse(input);
 
     println!("Part One");
     println!("Result: {}", part1::part1());

src/template/part1.rs

@@ -1,3 +1,4 @@
+#![allow(unused)]
 use crate::utilities::*;
 
 pub fn part1() -> usize {

src/template/part2.rs

@@ -1,3 +1,4 @@
+#![allow(unused)]
 use crate::utilities::*;
 
 pub fn part2() -> usize {

src/template/solve.rs

@@ -1,10 +1,11 @@
+#![allow(unused)]
 mod part1;
 mod part2;
 mod utilities;
 
 fn main() {
-    let _input = include_str!("./input.txt");
+    let input = include_str!("./input.txt");
-    let _structured_input = utilities::parse(_input);
+    let structured_input = utilities::parse(input);
 
     println!("Part One");
     println!("Result: {}", part1::part1());

src/template/utilities.rs

@@ -1,3 +1,4 @@
+#![allow(unused)]
 pub fn parse(input: &str) -> usize {
     unimplemented!()
 }