fix(client-brc): fixed edge cases in urc conversion

client-brc/src/brc.rs

@@ -103,11 +103,9 @@ pub mod brc_tree {
         pub fn write_structure(&self, mut file: &std::fs::File) -> anyhow::Result<()> {
             match &self.0 {
                 Some(node) => {
-                    file.write_all(format!("{},{}", node.min, node.max).as_bytes())?;
-                    file.write_all("(".as_bytes())?;
+                    file.write_all(format!("{},{}(", node.min, node.max).as_bytes())?;
                     node.left.write_structure(file)?;
-                    file.write_all(")".as_bytes())?;
-                    file.write_all("(".as_bytes())?;
+                    file.write_all(")(".as_bytes())?;
                     node.right.write_structure(file)?;
                     file.write_all(");".as_bytes())?;
                 }
@@ -142,9 +140,19 @@ pub mod brc_tree {
             }
         }
 
+        pub fn range_level(&self) -> (isize, isize, isize) {
+            match &self.0 {
+                Some(node) => (node.min, node.max, self.level()),
+                None => (0, 0, 0),
+            }
+        }
+
         pub fn level(&self) -> isize {
             match &self.0 {
                 Some(node) => {
+                    if node.max == node.min {
+                        return 0;
+                    }
                     let left = node.left.level();
                     let right = node.right.level();
                     1 + left.max(right)
@@ -156,21 +164,35 @@ pub mod brc_tree {
     #[test]
     fn test_possible_covers() {
         let tree = parse_from_file(std::path::Path::new("../brc_table.partitions")).unwrap();
-        let covers = tree.covers(0, 111000);
+        let mut covers = tree.covers(0, 111000);
         println!("{:?}", tree);
         println!("{:?}", covers.iter().map(|x| x.range()).collect::<Vec<_>>());
+        covers.sort_by_key(|a| a.level());
+        println!(
+            "{:?}",
+            brc_to_urc(covers)
+                .iter()
+                .map(|x| x.range())
+                .collect::<Vec<_>>()
+        );
     }
     pub fn parse_from_file(file_name: &Path) -> anyhow::Result<Subtree> {
         let contents = std::fs::read_to_string(file_name)?;
         parse_from_string(contents)
     }
 
+    impl PartialEq for Subtree {
+        fn eq(&self, other: &Self) -> bool {
+            self.range() == other.range()
+        }
+    }
+
     pub fn brc_to_urc(vec: Vec<Subtree>) -> Vec<Subtree> {
         // assume vec is sorted by level
         let mut deq = VecDeque::from(vec);
         let max_level = deq[deq.len() - 1].level();
-        let mut urc = vec![];
-        let mut seen = VecDeque::from_iter(0..max_level + 1);
+        let mut urc: Vec<Subtree> = vec![];
+        let mut seen = VecDeque::from_iter(0..=max_level + 1);
         while !deq.is_empty() {
             let node = deq.pop_front().unwrap().to_owned();
             if node.0.is_none() {
@@ -178,11 +200,15 @@ pub mod brc_tree {
             }
             match node.level() {
                 i if i < seen[0] => {
-                    urc.push(node);
+                    if !urc.contains(&node) {
+                        urc.push(node);
+                    }
                 }
                 i if i == seen[0] => {
                     seen.pop_front();
-                    urc.push(node);
+                    if !urc.contains(&node) {
+                        urc.push(node);
+                    }
                 }
                 _ => {
                     deq.push_front(node.clone().0.unwrap().left);
@@ -209,6 +235,13 @@ pub mod brc_tree {
         println!("{:?}", urc.iter().map(|x| x.range()).collect::<Vec<_>>());
     }
 
+    impl TryInto<Subtree> for String {
+        type Error = anyhow::Error;
+        fn try_into(self) -> Result<Subtree, Self::Error> {
+            parse_from_string(self)
+        }
+    }
+
     fn parse_from_string(s: String) -> anyhow::Result<Subtree> {
         let s = s.trim();
         if s.is_empty() {