Mercurial > public > mercurial-scm > hg

diff rust/hg-core/src/ancestors.rs @ 40300:72b94f946e90

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
rust: rustlazyancestors.__contains__ This changeset provides a Rust implementation of the iteration performed by lazyancestor.__contains__ It has the advantage over the Python iteration to use the 'seen' set encapsuled into the dedicated iterator (self._containsiter), rather than storing emitted items in another set (self._containsseen), and hence should reduce the memory footprint. Also, there's no need to convert intermediate emitted revisions back into Python integers. At this point, it would be tempting to implement the whole lazyancestor object in Rust, but that would lead to more C wrapping code (two objects) for little expected benefits.
author Georges Racinet <gracinet@anybox.fr>
date Mon, 08 Oct 2018 19:11:41 +0200
parents dbc28c91f7ff
children e13ab4acf555
line wrap: on
line diff
--- a/rust/hg-core/src/ancestors.rs	Sun Oct 14 01:39:22 2018 -0400
+++ b/rust/hg-core/src/ancestors.rs	Mon Oct 08 19:11:41 2018 +0200
@@ -80,6 +80,26 @@
         self.conditionally_push_rev(parents.1);
         Ok(())
     }
+
+    /// Consumes partially the iterator to tell if the given target
+    /// revision
+    /// is in the ancestors it emits.
+    /// This is meant for iterators actually dedicated to that kind of
+    /// purpose
+    pub fn contains(&mut self, target: Revision) -> bool {
+        if self.seen.contains(&target) && target != NULL_REVISION {
+            return true;
+        }
+        for rev in self {
+            if rev == target {
+                return true;
+            }
+            if rev < target {
+                return false;
+            }
+        }
+        false
+    }
 }
 
 /// Main implementation.
@@ -203,6 +223,18 @@
         assert_eq!(iter.next(), None)
     }
 
+    #[test]
+    fn test_contains() {
+        let mut lazy =
+            AncestorsIterator::new(Stub, vec![10, 1], 0, true).unwrap();
+        assert!(lazy.contains(1));
+        assert!(!lazy.contains(3));
+
+        let mut lazy =
+            AncestorsIterator::new(Stub, vec![0], 0, false).unwrap();
+        assert!(!lazy.contains(NULL_REVISION));
+    }
+
     /// A corrupted Graph, supporting error handling tests
     struct Corrupted;