Changing btree implementation

gemla/src/bracket/mod.rs

@@ -24,13 +24,16 @@ impl tree::Tree<Uuid> {
 // }
 
 /// Constructs a tree with a given height while simultaneously running a simulation on each node.
-fn build_tree(h: u32) -> Option<Box<tree::Tree<Uuid>>> {
+fn build_tree(h: u32) -> Option<tree::Tree<Uuid>> {
     // Recursively building a tree and running the simulation after wards to ensure a bottom-up
     // execution order.
     if h != 0 {
-        let tree = tree::Tree::new(Uuid::new_v4(), build_tree(h - 1), build_tree(h - 1));
+        let tree = btree!(
+                Uuid::new_v4(), 
+                build_tree(h - 1), 
+                build_tree(h - 1));
         tree.run_simulation();
-        Some(Box::new(tree))
+        Some(tree)
     } else {
         None
     }
@@ -42,7 +45,7 @@ fn build_tree(h: u32) -> Option<Box<tree::Tree<Uuid>>> {
 pub fn run_bracket() {
     let mut height = 1;
     let mut tree = FileLinked::new(
-        *build_tree(height).expect("Error getting result from build_tree"),
+        build_tree(height).expect("Error getting result from build_tree"),
         "for_tests",
     )
     .expect("Unable to create file linked object from tree");
@@ -52,10 +55,10 @@ pub fn run_bracket() {
         println!("=========================================");
         println!("Running bracket...");
         height += 1;
-        tree.replace(tree::Tree::new(
+        tree.replace(btree!(
             Uuid::new_v4(),
-            Some(Box::new(tree.readonly().clone())),
+            Some(tree.readonly().clone()),
-            build_tree(height),
+            build_tree(height)
         ))
         .expect("Error building up tree node");
         tree.readonly().run_simulation();

gemla/src/main.rs

@@ -32,12 +32,6 @@ fn main() {
             println!("{} is a valid directory!", directory);
             println!("Building tree for {}.", directory);
             bracket::run_bracket();
-
-            println!("\n\nReading tree from temp file.");
-            let tree: file_linked::FileLinked<tree::Tree<uuid::Uuid>> =
-                file_linked::FileLinked::from_file("./for_tests")
-                    .expect("Unable to read tree from existing file");
-            println!("Value read from file:\n{}", tree);
         }
         Ok(_) => println!("{} is not a valid directory!", directory),
         _ => println!("{} does not exist!", directory),

gemla/src/tests/file_linked.rs

@@ -3,7 +3,7 @@ use super::super::tree::Tree;
 
 #[test]
 fn test_mutate() -> Result<(), String> {
-    let tree = btree!(1, btree!(2), btree!(3, btree!(4),));
+    let tree = btree!(1, Some(btree!(2)), Some(btree!(3, Some(btree!(4)),)));
     let mut linked_tree = FileLinked::new(tree, "blah.txt")?;
 
     assert_eq!(

gemla/src/tests/tree.rs

@@ -19,14 +19,14 @@ fn test_new() {
 #[test]
 fn test_fmt() {
     assert_eq!(
-        format!("{}", btree!("foo", btree!("bar"),),),
+        format!("{}", btree!("foo", Some(btree!("bar")),),),
         "val = \"foo\"\n\n[left]\nval = \"bar\"\n"
     );
 }
 
 #[test]
 fn test_fmt_node() {
-    let t = btree!(17, btree!(16), btree!(12));
+    let t = btree!(17, Some(btree!(16)), Some(btree!(12)));
     assert_eq!(Tree::fmt_node(&t.left), "16");
     assert_eq!(
         Tree::fmt_node(&Some(Box::new(btree!(btree!("foo"))))),

gemla/src/tree/mod.rs

@@ -62,13 +62,13 @@ pub struct Tree<T> {
 ///
 /// ```
 /// // A tree with two child nodes.
-/// let t = btree!(1, btree!(2), btree!(3));
+/// let t = btree!(1, Some(btree!(2)), Some(btree!(3)));
 ///
 /// // A tree with only a left node.
-/// let t_left = btree!(1, btree!(2),);
+/// let t_left = btree!(1, Some(btree!(2)),);
 ///
 /// // A tree with only a right node.
-/// let t_right = btree!(1, ,btree!(3));
+/// let t_right = btree!(1, ,Some(btree!(3)));
 ///
 /// // A tree with no children nodes.
 /// let t_single = btree!(1)
@@ -76,13 +76,16 @@ pub struct Tree<T> {
 #[macro_export]
 macro_rules! btree {
     ($val:expr, $l:expr, $r:expr) => {
-        $crate::tree::Tree::new($val, Some(Box::new($l)), Some(Box::new($r)))
+        $crate::tree::Tree::new(
+                $val, 
+                $l.and_then(|l| Some(Box::new(l))), 
+                $r.and_then(|r| Some(Box::new(r))))
     };
     ($val:expr, , $r:expr) => {
-        $crate::tree::Tree::new($val, None, Some(Box::new($r)))
+        $crate::tree::Tree::new($val, None, $r.and_then(|r| Some(Box::new(r))))
     };
     ($val:expr, $l:expr,) => {
-        $crate::tree::Tree::new($val, Some(Box::new($l)), None)
+        $crate::tree::Tree::new($val, $l.and_then(|l| Some(Box::new(l))), None)
     };
     ($val:expr) => {
         Tree::new($val, None, None)