feat(libredirectionio): wip rework router and regex tree

Author: joelwurtz

Cargo.toml

@@ -44,6 +44,7 @@ scraper = "0.17.1"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.107"
 stderrlog = "0.5.4"
+tracing = "0.1.37"
 url = "2.4.1"
 
 [dev-dependencies]

src/lib.rs

@@ -25,3 +25,5 @@ mod callback_log;
 mod ffi;
 #[cfg(not(target_arch = "wasm32"))]
 mod ffi_helpers;
+mod regex_radix_tree_new;
+mod router_new;

src/regex_radix_tree_new/item.rs

@@ -0,0 +1,100 @@
+use super::leaf::Leaf;
+use super::node::Node;
+
+#[derive(Debug)]
+pub enum Item<V> {
+    Empty(bool),
+    Node(Node<V>),
+    Leaf(Leaf<V>),
+}
+
+impl<V> Item<V> {
+    /// Insert a new item into this node
+    pub fn insert(self, regex: &str, id: String, item: V) -> Item<V> {
+        match self {
+            Item::Empty(ignore_case) => Item::Leaf(Leaf::new(regex, id, item, ignore_case)),
+            Item::Node(node) => node.insert(regex, id, item),
+            Item::Leaf(leaf) => leaf.insert(regex, id, item),
+        }
+    }
+
+    /// Find values associated to this haystack
+    pub fn find(&self, haystack: &str) -> Vec<&V> {
+        match self {
+            Item::Empty(_) => Vec::new(),
+            Item::Node(node) => node.find(haystack),
+            Item::Leaf(leaf) => leaf.find(haystack),
+        }
+    }
+
+    pub fn get(&self, regex: &str) -> Vec<&V> {
+        match self {
+            Item::Empty(_) => Vec::new(),
+            Item::Node(node) => node.get(regex),
+            Item::Leaf(leaf) => leaf.get(regex),
+        }
+    }
+
+    pub fn get_mut(&mut self, regex: &str) -> Vec<&mut V> {
+        match self {
+            Item::Empty(_) => Vec::new(),
+            Item::Node(node) => node.get_mut(regex),
+            Item::Leaf(leaf) => leaf.get_mut(regex),
+        }
+    }
+
+    /// Remove an item on this tree
+    ///
+    /// This method returns true if there is no more data so it can be cleaned up
+    pub fn remove(self, id: &str) -> (Self, Option<V>) {
+        match self {
+            Item::Empty(_) => (self, None),
+            Item::Node(node) => node.remove(id),
+            Item::Leaf(leaf) => leaf.remove(id),
+        }
+    }
+
+    /// Length of node
+    pub fn len(&self) -> usize {
+        match self {
+            Item::Empty(_) => 0,
+            Item::Node(node) => node.len(),
+            Item::Leaf(leaf) => leaf.len(),
+        }
+    }
+
+    pub fn regex(&self) -> &str {
+        match self {
+            Item::Empty(_) => "",
+            Item::Node(node) => node.regex(),
+            Item::Leaf(leaf) => leaf.regex(),
+        }
+    }
+
+    /// Cache current regex according to a limit and a level
+    ///
+    /// This method must return new limit of element cached (passed limit minus number of element cached)
+    /// which allow other node to avoid caching extra node
+    ///
+    /// Implementation must not cache item if limit is equal to 0
+    /// Implementation must not cache item if not caching on the current node level
+    ///
+    /// Level argument allow to build cache on first level of the tree by priority
+    /// Implementation must retain at which level this node is build and not do any caching
+    /// if we are not on the current level
+    pub fn cache(&mut self, left: u64, max_level: u64, current_level: u64) -> u64 {
+        if left <= 0 {
+            return left;
+        }
+
+        if current_level > max_level {
+            return left;
+        }
+
+        match self {
+            Item::Empty(_) => left,
+            Item::Node(node) => node.cache(left, max_level, current_level),
+            Item::Leaf(leaf) => leaf.cache(left),
+        }
+    }
+}

src/regex_radix_tree_new/leaf.rs

@@ -0,0 +1,124 @@
+use super::item::Item;
+use super::node::Node;
+use super::prefix::common_prefix;
+use super::regex::LazyRegex;
+use std::collections::HashMap;
+
+#[derive(Debug)]
+pub struct Leaf<V> {
+    pub(crate) values: HashMap<String, V>,
+    pub(crate) regex: LazyRegex,
+}
+
+impl<V> Leaf<V> {
+    pub fn new(regex: &str, id: String, item: V, ignore_case: bool) -> Self {
+        let mut values = HashMap::new();
+        values.insert(id, item);
+
+        Leaf {
+            values,
+            regex: LazyRegex::new_leaf(regex, ignore_case),
+        }
+    }
+
+    /// Insert a new item into this node
+    pub fn insert(mut self, regex: &str, id: String, item: V) -> Item<V> {
+        if regex == self.regex.original.as_str() {
+            self.values.insert(id, item);
+
+            return Item::Leaf(self);
+        }
+
+        let prefix = common_prefix(self.regex.original.as_str(), regex);
+        let mut leaf_values = HashMap::new();
+        leaf_values.insert(id, item);
+
+        let leaf = Item::Leaf(Leaf {
+            values: leaf_values,
+            regex: LazyRegex::new_leaf(regex, self.regex.ignore_case),
+        });
+
+        Item::Node(Node {
+            regex: LazyRegex::new_node(prefix, self.regex.ignore_case),
+            children: vec![Item::Leaf(self), leaf],
+        })
+    }
+
+    /// Find values associated to this haystack
+    pub fn find(&self, haystack: &str) -> Vec<&V> {
+        if self.regex.is_match(haystack) {
+            return self.values.values().collect();
+        }
+
+        Vec::new()
+    }
+
+    pub fn get(&self, regex: &str) -> Vec<&V> {
+        if self.regex.original.as_str() == regex {
+            return self.values.values().collect();
+        }
+
+        Vec::new()
+    }
+
+    pub fn get_mut(&mut self, regex: &str) -> Vec<&mut V> {
+        if self.regex.original.as_str() == regex {
+            return self.values.values_mut().collect();
+        }
+
+        Vec::new()
+    }
+
+    /// Remove an item on this tree
+    ///
+    /// This method returns true if there is no more data so it can be cleaned up
+    pub fn remove(mut self, id: &str) -> (Item<V>, Option<V>) {
+        let removed = self.values.remove(id);
+
+        match removed {
+            None => (Item::Leaf(self), None),
+            Some(value) => {
+                if self.values.is_empty() {
+                    (Item::Empty(self.regex.ignore_case), Some(value))
+                } else {
+                    (Item::Leaf(self), Some(value))
+                }
+            }
+        }
+    }
+
+    /// Length of node
+    pub fn len(&self) -> usize {
+        self.values.len()
+    }
+
+    pub fn regex(&self) -> &str {
+        self.regex.original.as_str()
+    }
+
+    /// Cache current regex according to a limit and a level
+    ///
+    /// This method must return new limit of element cached (passed limit minus number of element cached)
+    /// which allow other node to avoid caching extra node
+    ///
+    /// Implementation must not cache item if limit is equal to 0
+    /// Implementation must not cache item if not caching on the current node level
+    ///
+    /// Level argument allow to build cache on first level of the tree by priority
+    /// Implementation must retain at which level this node is build and not do any caching
+    /// if we are not on the current level
+    pub fn cache(&mut self, left: u64) -> u64 {
+        // Already cached
+        if self.regex.compiled.is_some() {
+            return left;
+        }
+
+        self.regex.compile();
+
+        if self.regex.compiled.is_some() {
+            return left - 1;
+        }
+
+        left
+    }
+}

src/regex_radix_tree_new/mod.rs

@@ -0,0 +1,9 @@
+mod item;
+mod leaf;
+mod node;
+mod prefix;
+mod regex;
+mod trace;
+mod tree;
+
+pub use tree::{RegexTreeMap, UniqueRegexTreeMap};