Fix issue hroi#13 also for IpLookupTable::{matches, matches_mut}

Author: JakubOnderka

src/tree_bitmap/mod.rs

@@ -121,7 +121,7 @@ impl<T: Sized> TreeBitmap<T> {
             let match_mask = node::MATCH_MASKS[*nibble as usize];
 
             if let MatchResult::Match(result_hdl, result_index, matching_bit_index) =
-            cur_node.match_internal(match_mask)
+                cur_node.match_internal(match_mask)
             {
                 let bits_matched = bits_searched + node::BIT_MATCH[matching_bit_index as usize];
                 best_match = Some((result_hdl, result_index, bits_matched));
@@ -159,9 +159,10 @@ impl<T: Sized> TreeBitmap<T> {
     /// longest match lookup of ```nibbles```. Returns bits matched as u32, and mutable reference to T.
     pub fn longest_match_mut(&mut self, nibbles: &[u8]) -> Option<(u32, &mut T)> {
         match self.longest_match_internal(&nibbles) {
-            Some((result_hdl, result_index, bits_matched)) => {
-                Some((bits_matched, self.results.get_mut(&result_hdl, result_index)))
-            }
+            Some((result_hdl, result_index, bits_matched)) => Some((
+                bits_matched,
+                self.results.get_mut(&result_hdl, result_index),
+            )),
             None => None,
         }
     }
@@ -173,7 +174,15 @@ impl<T: Sized> TreeBitmap<T> {
         let mut bits_searched = 0;
         let mut matches = Vec::new();
 
-        for nibble in nibbles {
+        let mut loop_count = 0;
+        loop {
+            let nibble = if loop_count < nibbles.len() {
+                nibbles[loop_count]
+            } else {
+                0
+            };
+            loop_count += 1;
+            let nibble = &nibble;
             let cur_node = *self.trienodes.get(&cur_hdl, cur_index);
 
             for i in 0..5 {
@@ -668,12 +677,16 @@ mod tests {
         let (nibbles_b, mask_b) = (&[0, 10, 0, 10, 0, 10, 0, 0], 24);
         tbm.insert(nibbles_a, mask_a, "foo");
         tbm.insert(nibbles_b, mask_b, "bar");
+
         {
-            let matches = tbm.matches(nibbles_b);
+            let mut matches = tbm.matches(nibbles_b);
             assert_eq!(
                 true,
-                matches.contains(&(mask_a, &"foo")) && matches.contains(&(mask_b, &"bar"))
+                matches.any(|p| p == (mask_a, &"foo")) && matches.any(|p| p == (mask_b, &"bar"))
             );
+        }
+
+        {
             let value = tbm.remove(nibbles_b, mask_b);
             assert_eq!(value, Some("bar"));
             let lookup_result = tbm.longest_match(nibbles_b);

tests/tests.rs

@@ -102,19 +102,28 @@ fn longest_match() {
     assert_eq!(result, Some((Ipv4Addr::new(100, 64, 0, 0), 10, &100004)));
 
     let result = tbm.longest_match_mut(Ipv4Addr::new(100, 100, 100, 100));
-    assert_eq!(result, Some((Ipv4Addr::new(100, 64, 0, 0), 10, &mut 100004)));
+    assert_eq!(
+        result,
+        Some((Ipv4Addr::new(100, 64, 0, 0), 10, &mut 100004))
+    );
 
     let result = tbm.longest_match(Ipv4Addr::new(100, 64, 0, 100));
     assert_eq!(result, Some((Ipv4Addr::new(100, 64, 0, 0), 24, &10064024)));
 
     let result = tbm.longest_match_mut(Ipv4Addr::new(100, 64, 0, 100));
-    assert_eq!(result, Some((Ipv4Addr::new(100, 64, 0, 0), 24, &mut 10064024)));
+    assert_eq!(
+        result,
+        Some((Ipv4Addr::new(100, 64, 0, 0), 24, &mut 10064024))
+    );
 
     let result = tbm.longest_match(Ipv4Addr::new(100, 64, 1, 100));
     assert_eq!(result, Some((Ipv4Addr::new(100, 64, 1, 0), 24, &10064124)));
 
     let result = tbm.longest_match_mut(Ipv4Addr::new(100, 64, 1, 100));
-    assert_eq!(result, Some((Ipv4Addr::new(100, 64, 1, 0), 24, &mut 10064124)));
+    assert_eq!(
+        result,
+        Some((Ipv4Addr::new(100, 64, 1, 0), 24, &mut 10064124))
+    );
 
     let result = tbm.longest_match(Ipv4Addr::new(200, 200, 200, 200));
     assert_eq!(result, None);
@@ -123,14 +132,6 @@ fn longest_match() {
     assert_eq!(result, None);
 }
 
-#[test]
-fn matches() {
-    let mut tbm = IpLookupTable::new();
-    tbm.insert(Ipv4Addr::new(10, 0, 0, 0), 8, 1);
-    tbm.insert(Ipv4Addr::new(10, 1, 0, 0), 16, 2);
-    assert_eq!(2, tbm.matches(Ipv4Addr::new(10, 1, 0, 30)).count());
-}
-
 #[test]
 fn iter() {
     let mut tbl = IpLookupTable::new();
@@ -191,10 +192,17 @@ fn into_iter() {
 
 #[test]
 fn send() {
-    fn check_if_send<T: Send>() { }
+    fn check_if_send<T: Send>() {}
     check_if_send::<IpLookupTable<Ipv4Addr, ()>>();
 }
 
+#[test]
+fn matches() {
+    let mut tbm = IpLookupTable::new();
+    tbm.insert(Ipv4Addr::new(10, 0, 0, 0), 8, 1);
+    tbm.insert(Ipv4Addr::new(10, 1, 0, 0), 16, 2);
+    assert_eq!(2, tbm.matches(Ipv4Addr::new(10, 1, 0, 30)).count());
+}
 
 #[test]
 fn matches_all_zeros() {
@@ -242,7 +250,10 @@ fn matches_ipv6() {
     table.insert(more_specific, 48, "bar");
     assert_eq!(table.matches(less_specific).count(), 1);
     assert_eq!(table.matches(more_specific).count(), 2);
-    assert_eq!(table.matches(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0)).count(), 0);
+    assert_eq!(
+        table.matches(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0)).count(),
+        0
+    );
 }
 
 // https://github.com/hroi/treebitmap/issues/7
@@ -270,19 +281,21 @@ fn issue_13() {
     let mut table = IpLookupTable::new();
 
     println!("insert 28");
-    table.insert(Ipv4Addr::new(49, 255, 11, 16), 28, ());
+    table.insert(Ipv4Addr::new(49, 255, 11, 16), 28, 28);
     assert_eq!(
         table.exact_match(Ipv4Addr::new(49, 255, 11, 16), 28),
-        Some(&())
+        Some(&28)
     );
     println!("insert 32");
-    table.insert(ADDR, 32, ());
+    table.insert(ADDR, 32, 32);
 
     println!("match 32");
-    assert_eq!(table.exact_match(ADDR, 32), Some(&()));
+    assert_eq!(table.exact_match(ADDR, 32), Some(&32));
     assert!(table.longest_match(ADDR).is_some());
     assert!(table.longest_match_mut(ADDR).is_some());
 
+    assert_eq!(table.matches(ADDR).count(), 2);
+
     let v = table.remove(ADDR, 32);
     println!("removed: {:?}", v);
 }