feat(client-brc): Added function to convert brc to urc

client-brc/src/brc.rs

 pub mod brc_tree {
     #![allow(dead_code)]
-    use std::{io::Write, path::Path, vec};
+    use std::{collections::VecDeque, io::Write, path::Path, vec};
 
     use indexmap::IndexMap;
 
@@ -116,7 +116,8 @@ pub mod brc_tree {
             Ok(())
         }
 
-        pub fn possible_covers(&self, min: isize, max: isize) -> Vec<Subtree> {
+        pub fn covers(&self, min: isize, max: isize) -> Vec<Subtree> {
+            // Returns the set of nodes that covers the entire range
             match &self.0 {
                 Some(node) => {
                     if node.min > max || node.max < min {
@@ -125,8 +126,8 @@ pub mod brc_tree {
                     if min <= node.min && max >= node.max {
                         return vec![self.clone()];
                     }
-                    let mut left = node.left.possible_covers(min, max);
-                    let right = node.right.possible_covers(min, max);
+                    let mut left = node.left.covers(min, max);
+                    let right = node.right.covers(min, max);
                     left.extend(right);
                     left
                 }
@@ -140,11 +141,22 @@ pub mod brc_tree {
                 None => (0, 0),
             }
         }
+
+        pub fn level(&self) -> isize {
+            match &self.0 {
+                Some(node) => {
+                    let left = node.left.level();
+                    let right = node.right.level();
+                    1 + left.max(right)
+                }
+                None => -1,
+            }
+        }
     }
     #[test]
     fn test_possible_covers() {
         let tree = parse_from_file(std::path::Path::new("../brc_table.partitions")).unwrap();
-        let covers = tree.possible_covers(0, 111000);
+        let covers = tree.covers(0, 111000);
         println!("{:?}", tree);
         println!("{:?}", covers.iter().map(|x| x.range()).collect::<Vec<_>>());
     }
@@ -153,6 +165,50 @@ pub mod brc_tree {
         parse_from_string(contents)
     }
 
+    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);
+        while !deq.is_empty() {
+            let node = deq.pop_front().unwrap().to_owned();
+            if node.0.is_none() {
+                continue;
+            }
+            match node.level() {
+                i if i < seen[0] => {
+                    urc.push(node);
+                }
+                i if i == seen[0] => {
+                    seen.pop_front();
+                    urc.push(node);
+                }
+                _ => {
+                    deq.push_front(node.clone().0.unwrap().left);
+                    deq.push_front(node.0.unwrap().right);
+                }
+            }
+        }
+        urc
+    }
+
+    #[test]
+    fn test_brc_to_urc() {
+        let tree = from_sorted_list(indexmap::indexmap! {
+            0 => vec!["a".to_string()],
+            1 => vec!["a".to_string()],
+            2 => vec!["b".to_string()],
+            3 => vec!["c".to_string()],
+            4 => vec!["d".to_string()],
+            5 => vec!["e".to_string()],
+            6 => vec!["f".to_string()],
+            7 => vec!["g".to_string()],
+        });
+        let urc = brc_to_urc(tree.covers(2, 7));
+        println!("{:?}", urc.iter().map(|x| x.range()).collect::<Vec<_>>());
+    }
+
     fn parse_from_string(s: String) -> anyhow::Result<Subtree> {
         let s = s.trim();
         if s.is_empty() {