Merge pull request michaelsproul#37 from vks/prefix

michaelsproul · web-flow · commit e3f5ce443eca · 2018-02-25T16:49:52.000+11:00
Make it possible to get the prefix of a node
diff --git a/README.md b/README.md
@@ -27,8 +27,7 @@ Available on [Crates.io][] as [`radix_trie`][radix-crate].
 Just add `radix_trie` to the dependencies section of your `Cargo.toml`, like so:
 
 ```toml
-[dependencies]
-radix_trie = "*"
+radix_trie = "0.1"
 ```
 
 # Contributors
diff --git a/src/iter.rs b/src/iter.rs
@@ -100,24 +100,24 @@ impl<'a, K, V> Iterator for Children<'a, K, V> {
         self.inner.next().map(|node| {
             SubTrie {
                 prefix: self.prefix.clone().join(&node.key),
-                node: &node,
+                node: node,
             }
         })
     }
 }
 
 impl<K, V> TrieNode<K, V> {
     /// Helper function to get all the non-empty children of a node.
-    fn child_iter<'a>(&'a self) -> ChildIter<'a, K, V> {
-        fn id<'b, K, V>(x: &'b Option<Child<K, V>>) -> Option<&'b Child<K, V>> {
+    fn child_iter(&self) -> ChildIter<K, V> {
+        fn id<K, V>(x: &Option<Child<K, V>>) -> Option<&Child<K, V>> {
             x.as_ref()
         }
 
         self.children.iter().filter_map(id)
     }
 
     /// Get the key and value of a node as a pair.
-    fn kv_as_pair<'a>(&'a self) -> Option<(&'a K, &'a V)> {
+    fn kv_as_pair(&self) -> Option<(&K, &V)> {
         self.key_value.as_ref().map(|kv| (&kv.key, &kv.value))
     }
 }
@@ -146,7 +146,7 @@ impl<'a, K, V> Iterator for Iter<'a, K, V> {
             let action = match self.stack.last_mut() {
                 Some(stack_top) => {
                     match stack_top.next() {
-                        Some(child) => Push(&child),
+                        Some(child) => Push(child),
                         None => Pop,
                     }
                 }
diff --git a/src/keys.rs b/src/keys.rs
@@ -72,7 +72,7 @@ pub fn check_keys<K: ?Sized>(key1: &K, key2: &K)
     }
 }
 
-/// --- TrieKey Implementations for standard types --- ///
+// --- TrieKey Implementations for standard types --- ///
 
 // This blanket implementation goes into play when specialization is stabilized
 // impl<T> TrieKey for T where T: Into<Vec<u8>> + Clone + Eq + PartialEq {
@@ -90,7 +90,7 @@ impl TrieKey for Vec<u8> {
 
 impl TrieKey for [u8] {
     fn encode_bytes(&self) -> Vec<u8> {
-        self.clone().to_vec()
+        self.to_vec()
     }
 }
 
@@ -122,15 +122,15 @@ impl TrieKey for i8 {
     fn encode_bytes(&self) -> Vec<u8> {
         let mut v: Vec<u8> = Vec::with_capacity(1);
         v.push(*self as u8);
-        return v;
+        v
     }
 }
 
 impl TrieKey for u8 {
     fn encode_bytes(&self) -> Vec<u8> {
         let mut v: Vec<u8> = Vec::with_capacity(1);
         v.push(*self);
-        return v;
+        v
     }
 }
 
diff --git a/src/test.rs b/src/test.rs
@@ -423,3 +423,20 @@ fn test_get_raw_descendant_borrow() {
     let subtrie = trie.get_raw_descendant("/boot/lo").unwrap();
     assert_eq!(*subtrie.value().unwrap(), "lol");
 }
+
+#[test]
+fn test_prefix() {
+    let mut t = Trie::<u8, ()>::new();
+    t.insert(0xf1, ());
+    t.insert(0xf2, ());
+    println!("{:#?}", t);
+    assert_eq!(t.prefix(), [].as_ref());
+    let first = t.children().next().unwrap();
+    assert_eq!(first.prefix(), [0xf].as_ref());
+    let mut c = first.children();
+    let second = c.next().unwrap();
+    let third = c.next().unwrap();
+    assert!(c.next().is_none());
+    assert_eq!(second.prefix(), [0x1].as_ref());
+    assert_eq!(third.prefix(), [0x2].as_ref());
+}
diff --git a/src/traversal.rs b/src/traversal.rs
@@ -81,11 +81,11 @@ macro_rules! get_func {
 get_func!(name: iterative_get, trie_type: &'a TrieNode<K, V>, mutability: );
 get_func!(name: iterative_get_mut, trie_type: &'a mut TrieNode<K, V>, mutability: mut);
 
-fn iterative_insert<'a, K, V>(trie: &'a mut TrieNode<K, V>,
-                              key: K,
-                              value: V,
-                              mut nv: NibbleVec)
-                              -> Option<V>
+fn iterative_insert<K, V>(trie: &mut TrieNode<K, V>,
+                          key: K,
+                          value: V,
+                          mut nv: NibbleVec)
+                          -> Option<V>
     where K: TrieKey
 {
     if nv.len() == 0 {
@@ -255,11 +255,11 @@ fn get_ancestor<'a, K, V>(trie: &'a TrieNode<K, V>,
         let bucket = nv.get(depth) as usize;
         let current = prev;
         if let Some(ref child) = current.children[bucket] {
-            match match_keys(depth, &nv, &child.key) {
+            match match_keys(depth, nv, &child.key) {
                 KeyMatch::Full => {
                     return child.as_value_node()
                         .map(|node| (node, depth + node.key.len()))
-                        .or(ancestor.map(|anc| (anc, depth)));
+                        .or_else(|| ancestor.map(|anc| (anc, depth)));
                 }
                 KeyMatch::FirstPrefix |
                 KeyMatch::Partial(_) => {
@@ -296,7 +296,7 @@ fn get_raw_ancestor<'a, K, V>(trie: &'a TrieNode<K, V>,
         let bucket = nv.get(depth) as usize;
         let current = prev;
         if let Some(ref child) = current.children[bucket] {
-            match match_keys(depth, &nv, &child.key) {
+            match match_keys(depth, nv, &child.key) {
                 KeyMatch::Full => {
                     return (child, depth + child.key.len());
                 }
@@ -337,7 +337,7 @@ fn get_raw_descendant<'a, K, V>(trie: &'a TrieNode<K, V>,
         let bucket = nv.get(depth) as usize;
         let current = prev;
         if let Some(ref child) = current.children[bucket] {
-            match match_keys(depth, &nv, &child.key) {
+            match match_keys(depth, nv, &child.key) {
                 KeyMatch::Full => {
                     return Some(NoModification(child));
                 }
diff --git a/src/trie.rs b/src/trie.rs
@@ -180,3 +180,9 @@ impl<K, V> PartialEq for Trie<K, V> where K: TrieKey, V: PartialEq {
         )
     }
 }
+
+impl<K: TrieKey, V> Default for Trie<K, V> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
diff --git a/src/trie_common.rs b/src/trie_common.rs
@@ -1,4 +1,4 @@
-use {Trie, TrieKey, SubTrie, SubTrieMut};
+use {NibbleVec, Trie, TrieKey, SubTrie, SubTrieMut};
 use trie_node::TrieNode;
 use iter::*;
 
@@ -47,6 +47,11 @@ pub trait TrieCommon<'a, K: 'a, V: 'a>: ContainsTrieNode<'a, K, V>
 
     /// Return an iterator over the child subtries of this node.
     fn children(self) -> Children<'a, K, V>;
+
+    /// Get the prefix of this node.
+    fn prefix(self) -> &'a NibbleVec {
+        &self.trie_node().key
+    }
 }
 
 /// Helper trait for Trie/SubTrie/SubTrieMut, which all contain a trie node.
diff --git a/src/trie_node.rs b/src/trie_node.rs
@@ -1,4 +1,5 @@
 use std::borrow::Borrow;
+use std::default::Default;
 use {SubTrie, SubTrieMut, NibbleVec, BRANCH_FACTOR};
 use keys::*;
 
@@ -104,7 +105,7 @@ impl<K, V> TrieNode<K, V>
         let mut size = if self.key_value.is_some() { 1 } else { 0 };
 
         for child in &self.children {
-            if let &Some(ref child) = child {
+            if let Some(ref child) = *child {
                 // TODO: could unroll this recursion
                 size += child.compute_size();
             }
@@ -130,7 +131,7 @@ impl<K, V> TrieNode<K, V>
 
     /// Helper function for removing the single child of a node.
     pub fn take_only_child(&mut self) -> Box<TrieNode<K, V>> {
-        debug_assert!(self.child_count == 1);
+        debug_assert_eq!(self.child_count, 1);
         for i in 0..BRANCH_FACTOR {
             if let Some(child) = self.take_child(i) {
                 return child;
@@ -206,7 +207,7 @@ impl<K, V> TrieNode<K, V>
         }));
     }
 
-    pub fn as_subtrie<'a>(&'a self, prefix: NibbleVec) -> SubTrie<'a, K, V> {
+    pub fn as_subtrie(&self, prefix: NibbleVec) -> SubTrie<K, V> {
         SubTrie {
             prefix: prefix,
             node: self
@@ -256,17 +257,14 @@ impl<K, V> TrieNode<K, V>
         let trie_key = prefix.clone().join(&self.key);
 
         // Account for this node in the size check, and check its key.
-        match self.key_value {
-            Some(ref kv) => {
-                sub_tree_size += 1;
+        if let Some(ref kv) = self.key_value {
+            sub_tree_size += 1;
 
-                let actual_key = kv.key.encode();
+            let actual_key = kv.key.encode();
 
-                if trie_key != actual_key {
-                    return (false, sub_tree_size);
-                }
+            if trie_key != actual_key {
+                return (false, sub_tree_size);
             }
-            None => (),
         }
 
         // Recursively check children.
@@ -282,3 +280,9 @@ impl<K, V> TrieNode<K, V>
         (true, sub_tree_size)
     }
 }
+
+impl<K: TrieKey, V> Default for TrieNode<K, V> {
+    fn default() -> Self {
+        Self::new()
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -100,24 +100,24 @@ impl<'a, K, V> Iterator for Children<'a, K, V> {`
`100`	`100`	`self.inner.next().map(\|node\| {`
`101`	`101`	`SubTrie {`
`102`	`102`	`prefix: self.prefix.clone().join(&node.key),`
`103`		`- node: &node,`
	`103`	`+ node: node,`
`104`	`104`	`}`
`105`	`105`	`})`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`impl<K, V> TrieNode<K, V> {`
`110`	`110`	`/// Helper function to get all the non-empty children of a node.`
`111`		`- fn child_iter<'a>(&'a self) -> ChildIter<'a, K, V> {`
`112`		`- fn id<'b, K, V>(x: &'b Option<Child<K, V>>) -> Option<&'b Child<K, V>> {`
	`111`	`+ fn child_iter(&self) -> ChildIter<K, V> {`
	`112`	`+ fn id<K, V>(x: &Option<Child<K, V>>) -> Option<&Child<K, V>> {`
`113`	`113`	`x.as_ref()`
`114`	`114`	`}`
`115`	`115`
`116`	`116`	`self.children.iter().filter_map(id)`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`/// Get the key and value of a node as a pair.`
`120`		`- fn kv_as_pair<'a>(&'a self) -> Option<(&'a K, &'a V)> {`
	`120`	`+ fn kv_as_pair(&self) -> Option<(&K, &V)> {`
`121`	`121`	`self.key_value.as_ref().map(\|kv\| (&kv.key, &kv.value))`
`122`	`122`	`}`
`123`	`123`	`}`
`@@ -146,7 +146,7 @@ impl<'a, K, V> Iterator for Iter<'a, K, V> {`
`146`	`146`	`let action = match self.stack.last_mut() {`
`147`	`147`	`Some(stack_top) => {`
`148`	`148`	`match stack_top.next() {`
`149`		`- Some(child) => Push(&child),`
	`149`	`+ Some(child) => Push(child),`
`150`	`150`	`None => Pop,`
`151`	`151`	`}`
`152`	`152`	`}`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ pub fn check_keys<K: ?Sized>(key1: &K, key2: &K)`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`
`75`		`-/// --- TrieKey Implementations for standard types --- ///`
	`75`	`+// --- TrieKey Implementations for standard types --- ///`
`76`	`76`
`77`	`77`	`// This blanket implementation goes into play when specialization is stabilized`
`78`	`78`	`// impl<T> TrieKey for T where T: Into<Vec<u8>> + Clone + Eq + PartialEq {`
`@@ -90,7 +90,7 @@ impl TrieKey for Vec<u8> {`
`90`	`90`
`91`	`91`	`impl TrieKey for [u8] {`
`92`	`92`	`fn encode_bytes(&self) -> Vec<u8> {`
`93`		`- self.clone().to_vec()`
	`93`	`+ self.to_vec()`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`
`@@ -122,15 +122,15 @@ impl TrieKey for i8 {`
`122`	`122`	`fn encode_bytes(&self) -> Vec<u8> {`
`123`	`123`	`let mut v: Vec<u8> = Vec::with_capacity(1);`
`124`	`124`	`v.push(*self as u8);`
`125`		`- return v;`
	`125`	`+ v`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`impl TrieKey for u8 {`
`130`	`130`	`fn encode_bytes(&self) -> Vec<u8> {`
`131`	`131`	`let mut v: Vec<u8> = Vec::with_capacity(1);`
`132`	`132`	`v.push(*self);`
`133`		`- return v;`
	`133`	`+ v`
`134`	`134`	`}`
`135`	`135`	`}`
`136`	`136`
Original file line number	Diff line number	Diff line change
`@@ -180,3 +180,9 @@ impl<K, V> PartialEq for Trie<K, V> where K: TrieKey, V: PartialEq {`
`180`	`180`	`)`
`181`	`181`	`}`
`182`	`182`	`}`
	`183`	`+`
	`184`	`+impl<K: TrieKey, V> Default for Trie<K, V> {`
	`185`	`+ fn default() -> Self {`
	`186`	`+ Self::new()`
	`187`	`+ }`
	`188`	`+}`