mercurial-scm/hg: rust/hg-core/src/ancestors.rs annotate

annotate rust/hg-core/src/ancestors.rs @ 52300:04b9a56c2d25

rust-lib: only export very common types to the top of the crate This was done very early in the Rust project's lifecycle and I had very little Rust experience. Let's keep the `DirstateParents` since they'll pop up in all higher-level code and make the rest more explicit imports to make the imports less confusing and the lib less cluttered.

author	Rapha?l Gom?s <rgomes@octobus.net>
date	Mon, 04 Nov 2024 11:13:05 +0100
parents	f90796d33aa0
children	e9ced84aeef4

rev	line source
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	1 // ancestors.rs
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	2 //
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	3 // Copyright 2018 Georges Racinet <gracinet@anybox.fr>
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	4 //
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	5 // This software may be used and distributed according to the terms of the
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	6 // GNU General Public License version 2 or any later version.
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	7
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	8 //! Rust versions of generic DAG ancestors algorithms for Mercurial
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	9
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	10 use super::{Graph, GraphError, Revision, NULL_REVISION};
42327 e8f3740cc067 rust-filepatterns: add a Rust implementation of pattern-related utils Rapha?l Gom?s <rgomes@octobus.net> parents: 41717 diff changeset	11 use crate::dagops;
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	12 use std::cmp::max;
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	13 use std::collections::{BinaryHeap, HashSet};
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	14
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	15 /// Iterator over the ancestors of a given list of revisions
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	16 /// This is a generic type, defined and implemented for any Graph, so that
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	17 /// it's easy to
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	18 ///
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	19 /// - unit test in pure Rust
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	20 /// - bind to main Mercurial code, potentially in several ways and have these
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	21 /// bindings evolve over time
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	22 pub struct AncestorsIterator<G: Graph> {
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	23 graph: G,
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	24 visit: BinaryHeap<Revision>,
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	25 seen: HashSet<Revision>,
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	26 stoprev: Revision,
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	27 }
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	28
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	29 pub struct MissingAncestors<G: Graph> {
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	30 graph: G,
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	31 bases: HashSet<Revision>,
41717 9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	32 max_base: Revision,
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	33 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	34
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	35 impl<G: Graph> AncestorsIterator<G> {
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	36 /// Constructor.
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	37 ///
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	38 /// if `inclusive` is true, then the init revisions are emitted in
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	39 /// particular, otherwise iteration starts from their parents.
41105 35ee590b1892 rust: use 'impl Trait' in method argument of AncestorsIterator Yuya Nishihara <yuya@tcha.org> parents: 41104 diff changeset	40 pub fn new(
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	41 graph: G,
41105 35ee590b1892 rust: use 'impl Trait' in method argument of AncestorsIterator Yuya Nishihara <yuya@tcha.org> parents: 41104 diff changeset	42 initrevs: impl IntoIterator<Item = Revision>,
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	43 stoprev: Revision,
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	44 inclusive: bool,
41105 35ee590b1892 rust: use 'impl Trait' in method argument of AncestorsIterator Yuya Nishihara <yuya@tcha.org> parents: 41104 diff changeset	45 ) -> Result<Self, GraphError> {
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	46 let filtered_initrevs = initrevs.into_iter().filter(\|&r\| r >= stoprev);
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	47 if inclusive {
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	48 let visit: BinaryHeap<Revision> = filtered_initrevs.collect();
44973 26114bd6ec60 rust: do a clippy pass Rapha?l Gom?s <rgomes@octobus.net> parents: 42841 diff changeset	49 let seen = visit.iter().cloned().collect();
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	50 return Ok(AncestorsIterator {
44973 26114bd6ec60 rust: do a clippy pass Rapha?l Gom?s <rgomes@octobus.net> parents: 42841 diff changeset	51 visit,
26114bd6ec60 rust: do a clippy pass Rapha?l Gom?s <rgomes@octobus.net> parents: 42841 diff changeset	52 seen,
26114bd6ec60 rust: do a clippy pass Rapha?l Gom?s <rgomes@octobus.net> parents: 42841 diff changeset	53 stoprev,
26114bd6ec60 rust: do a clippy pass Rapha?l Gom?s <rgomes@octobus.net> parents: 42841 diff changeset	54 graph,
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	55 });
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	56 }
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	57 let mut this = AncestorsIterator {
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	58 visit: BinaryHeap::new(),
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	59 seen: HashSet::new(),
44973 26114bd6ec60 rust: do a clippy pass Rapha?l Gom?s <rgomes@octobus.net> parents: 42841 diff changeset	60 stoprev,
26114bd6ec60 rust: do a clippy pass Rapha?l Gom?s <rgomes@octobus.net> parents: 42841 diff changeset	61 graph,
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	62 };
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	63 this.seen.insert(NULL_REVISION);
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	64 for rev in filtered_initrevs {
40933 18513d6ef7d4 rust: changed Graph.parents to return [Revision; 2] Georges Racinet <gracinet@anybox.fr> parents: 40932 diff changeset	65 for parent in this.graph.parents(rev)?.iter().cloned() {
18513d6ef7d4 rust: changed Graph.parents to return [Revision; 2] Georges Racinet <gracinet@anybox.fr> parents: 40932 diff changeset	66 this.conditionally_push_rev(parent);
18513d6ef7d4 rust: changed Graph.parents to return [Revision; 2] Georges Racinet <gracinet@anybox.fr> parents: 40932 diff changeset	67 }
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	68 }
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	69 Ok(this)
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	70 }
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	71
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	72 #[inline]
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	73 fn conditionally_push_rev(&mut self, rev: Revision) {
41714 70827ebba453 rust: less set lookups in AncestorsIterator Georges Racinet <georges.racinet@octobus.net> parents: 41246 diff changeset	74 if self.stoprev <= rev && self.seen.insert(rev) {
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	75 self.visit.push(rev);
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	76 }
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	77 }
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	78
40300 72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40271 diff changeset	79 /// Consumes partially the iterator to tell if the given target
72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40271 diff changeset	80 /// revision
72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40271 diff changeset	81 /// is in the ancestors it emits.
72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40271 diff changeset	82 /// This is meant for iterators actually dedicated to that kind of
72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40271 diff changeset	83 /// purpose
40863 443eb4bc41af rust: propagate error of index_get_parents() properly Yuya Nishihara <yuya@tcha.org> parents: 40832 diff changeset	84 pub fn contains(&mut self, target: Revision) -> Result<bool, GraphError> {
40300 72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40271 diff changeset	85 if self.seen.contains(&target) && target != NULL_REVISION {
40863 443eb4bc41af rust: propagate error of index_get_parents() properly Yuya Nishihara <yuya@tcha.org> parents: 40832 diff changeset	86 return Ok(true);
40300 72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40271 diff changeset	87 }
40863 443eb4bc41af rust: propagate error of index_get_parents() properly Yuya Nishihara <yuya@tcha.org> parents: 40832 diff changeset	88 for item in self {
443eb4bc41af rust: propagate error of index_get_parents() properly Yuya Nishihara <yuya@tcha.org> parents: 40832 diff changeset	89 let rev = item?;
40300 72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40271 diff changeset	90 if rev == target {
40863 443eb4bc41af rust: propagate error of index_get_parents() properly Yuya Nishihara <yuya@tcha.org> parents: 40832 diff changeset	91 return Ok(true);
40300 72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40271 diff changeset	92 }
72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40271 diff changeset	93 if rev < target {
40863 443eb4bc41af rust: propagate error of index_get_parents() properly Yuya Nishihara <yuya@tcha.org> parents: 40832 diff changeset	94 return Ok(false);
40300 72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40271 diff changeset	95 }
72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40271 diff changeset	96 }
40863 443eb4bc41af rust: propagate error of index_get_parents() properly Yuya Nishihara <yuya@tcha.org> parents: 40832 diff changeset	97 Ok(false)
40300 72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40271 diff changeset	98 }
41054 ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	99
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	100 pub fn peek(&self) -> Option<Revision> {
44973 26114bd6ec60 rust: do a clippy pass Rapha?l Gom?s <rgomes@octobus.net> parents: 42841 diff changeset	101 self.visit.peek().cloned()
41054 ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	102 }
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	103
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	104 /// Tell if the iterator is about an empty set
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	105 ///
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	106 /// The result does not depend whether the iterator has been consumed
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	107 /// or not.
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	108 /// This is mostly meant for iterators backing a lazy ancestors set
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	109 pub fn is_empty(&self) -> bool {
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	110 if self.visit.len() > 0 {
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	111 return false;
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	112 }
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	113 if self.seen.len() > 1 {
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	114 return false;
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	115 }
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	116 // at this point, the seen set is at most a singleton.
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	117 // If not `self.inclusive`, it's still possible that it has only
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	118 // the null revision
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	119 self.seen.is_empty() \|\| self.seen.contains(&NULL_REVISION)
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	120 }
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	121 }
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	122
41054 ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	123 /// Main implementation for the iterator
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	124 ///
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	125 /// The algorithm is the same as in `_lazyancestorsiter()` from `ancestors.py`
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	126 /// with a few non crucial differences:
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	127 ///
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	128 /// - there's no filtering of invalid parent revisions. Actually, it should be
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	129 /// consistent and more efficient to filter them from the end caller.
40932 dc38d976ff4d rust: improved docstring Georges Racinet <gracinet@anybox.fr> parents: 40929 diff changeset	130 /// - we don't have the optimization for adjacent revisions (i.e., the case
dc38d976ff4d rust: improved docstring Georges Racinet <gracinet@anybox.fr> parents: 40929 diff changeset	131 /// where `p1 == rev - 1`), because it amounts to update the first element of
dc38d976ff4d rust: improved docstring Georges Racinet <gracinet@anybox.fr> parents: 40929 diff changeset	132 /// the heap without sifting, which Rust's BinaryHeap doesn't let us do.
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	133 /// - we save a few pushes by comparing with `stoprev` before pushing
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	134 impl<G: Graph> Iterator for AncestorsIterator<G> {
40863 443eb4bc41af rust: propagate error of index_get_parents() properly Yuya Nishihara <yuya@tcha.org> parents: 40832 diff changeset	135 type Item = Result<Revision, GraphError>;
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	136
40863 443eb4bc41af rust: propagate error of index_get_parents() properly Yuya Nishihara <yuya@tcha.org> parents: 40832 diff changeset	137 fn next(&mut self) -> Option<Self::Item> {
40811 e13ab4acf555 rust: peek_mut optim for lazy ancestors Georges Racinet <gracinet@anybox.fr> parents: 40300 diff changeset	138 let current = match self.visit.peek() {
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	139 None => {
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	140 return None;
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	141 }
40811 e13ab4acf555 rust: peek_mut optim for lazy ancestors Georges Racinet <gracinet@anybox.fr> parents: 40300 diff changeset	142 Some(c) => *c,
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	143 };
40933 18513d6ef7d4 rust: changed Graph.parents to return [Revision; 2] Georges Racinet <gracinet@anybox.fr> parents: 40932 diff changeset	144 let [p1, p2] = match self.graph.parents(current) {
40863 443eb4bc41af rust: propagate error of index_get_parents() properly Yuya Nishihara <yuya@tcha.org> parents: 40832 diff changeset	145 Ok(ps) => ps,
443eb4bc41af rust: propagate error of index_get_parents() properly Yuya Nishihara <yuya@tcha.org> parents: 40832 diff changeset	146 Err(e) => return Some(Err(e)),
443eb4bc41af rust: propagate error of index_get_parents() properly Yuya Nishihara <yuya@tcha.org> parents: 40832 diff changeset	147 };
41714 70827ebba453 rust: less set lookups in AncestorsIterator Georges Racinet <georges.racinet@octobus.net> parents: 41246 diff changeset	148 if p1 < self.stoprev \|\| !self.seen.insert(p1) {
40811 e13ab4acf555 rust: peek_mut optim for lazy ancestors Georges Racinet <gracinet@anybox.fr> parents: 40300 diff changeset	149 self.visit.pop();
e13ab4acf555 rust: peek_mut optim for lazy ancestors Georges Racinet <gracinet@anybox.fr> parents: 40300 diff changeset	150 } else {
e13ab4acf555 rust: peek_mut optim for lazy ancestors Georges Racinet <gracinet@anybox.fr> parents: 40300 diff changeset	151 *(self.visit.peek_mut().unwrap()) = p1;
e13ab4acf555 rust: peek_mut optim for lazy ancestors Georges Racinet <gracinet@anybox.fr> parents: 40300 diff changeset	152 };
e13ab4acf555 rust: peek_mut optim for lazy ancestors Georges Racinet <gracinet@anybox.fr> parents: 40300 diff changeset	153
40832 70976974c14a rust: rename local variables in AncestorsIterator::next Georges Racinet <georges@racinet.fr> parents: 40811 diff changeset	154 self.conditionally_push_rev(p2);
40863 443eb4bc41af rust: propagate error of index_get_parents() properly Yuya Nishihara <yuya@tcha.org> parents: 40832 diff changeset	155 Some(Ok(current))
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	156 }
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	157 }
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	158
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	159 impl<G: Graph> MissingAncestors<G> {
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	160 pub fn new(graph: G, bases: impl IntoIterator<Item = Revision>) -> Self {
41717 9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	161 let mut created = MissingAncestors {
44973 26114bd6ec60 rust: do a clippy pass Rapha?l Gom?s <rgomes@octobus.net> parents: 42841 diff changeset	162 graph,
41717 9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	163 bases: HashSet::new(),
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	164 max_base: NULL_REVISION,
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	165 };
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	166 created.add_bases(bases);
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	167 created
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	168 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	169
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	170 pub fn has_bases(&self) -> bool {
41716 977432970080 rust: stop putting NULL_REVISION in MissingAncestors.bases Georges Racinet <georges.racinet@octobus.net> parents: 41715 diff changeset	171 !self.bases.is_empty()
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	172 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	173
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	174 /// Return a reference to current bases.
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	175 ///
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	176 /// This is useful in unit tests, but also setdiscovery.py does
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	177 /// read the bases attribute of a ancestor.missingancestors instance.
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49631 diff changeset	178 pub fn get_bases(&self) -> &HashSet<Revision> {
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	179 &self.bases
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	180 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	181
41246 619ee4039bd4 rust: MissingAncestors.basesheads() Georges Racinet <georges.racinet@octobus.net> parents: 41241 diff changeset	182 /// Computes the relative heads of current bases.
619ee4039bd4 rust: MissingAncestors.basesheads() Georges Racinet <georges.racinet@octobus.net> parents: 41241 diff changeset	183 ///
619ee4039bd4 rust: MissingAncestors.basesheads() Georges Racinet <georges.racinet@octobus.net> parents: 41241 diff changeset	184 /// The object is still usable after this.
619ee4039bd4 rust: MissingAncestors.basesheads() Georges Racinet <georges.racinet@octobus.net> parents: 41241 diff changeset	185 pub fn bases_heads(&self) -> Result<HashSet<Revision>, GraphError> {
619ee4039bd4 rust: MissingAncestors.basesheads() Georges Racinet <georges.racinet@octobus.net> parents: 41241 diff changeset	186 dagops::heads(&self.graph, self.bases.iter())
619ee4039bd4 rust: MissingAncestors.basesheads() Georges Racinet <georges.racinet@octobus.net> parents: 41241 diff changeset	187 }
619ee4039bd4 rust: MissingAncestors.basesheads() Georges Racinet <georges.racinet@octobus.net> parents: 41241 diff changeset	188
619ee4039bd4 rust: MissingAncestors.basesheads() Georges Racinet <georges.racinet@octobus.net> parents: 41241 diff changeset	189 /// Consumes the object and returns the relative heads of its bases.
41717 9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	190 pub fn into_bases_heads(
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	191 mut self,
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	192 ) -> Result<HashSet<Revision>, GraphError> {
41246 619ee4039bd4 rust: MissingAncestors.basesheads() Georges Racinet <georges.racinet@octobus.net> parents: 41241 diff changeset	193 dagops::retain_heads(&self.graph, &mut self.bases)?;
619ee4039bd4 rust: MissingAncestors.basesheads() Georges Racinet <georges.racinet@octobus.net> parents: 41241 diff changeset	194 Ok(self.bases)
619ee4039bd4 rust: MissingAncestors.basesheads() Georges Racinet <georges.racinet@octobus.net> parents: 41241 diff changeset	195 }
619ee4039bd4 rust: MissingAncestors.basesheads() Georges Racinet <georges.racinet@octobus.net> parents: 41241 diff changeset	196
41717 9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	197 /// Add some revisions to `self.bases`
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	198 ///
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	199 /// Takes care of keeping `self.max_base` up to date.
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	200 pub fn add_bases(
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	201 &mut self,
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	202 new_bases: impl IntoIterator<Item = Revision>,
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	203 ) {
41717 9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	204 let mut max_base = self.max_base;
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	205 self.bases.extend(
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	206 new_bases
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	207 .into_iter()
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	208 .filter(\|&rev\| rev != NULL_REVISION)
52291 f90796d33aa0 rust: fix clippy lints Rapha?l Gom?s <rgomes@octobus.net> parents: 51616 diff changeset	209 .inspect(\|&r\| {
41717 9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	210 if r > max_base {
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	211 max_base = r;
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	212 }
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	213 }),
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	214 );
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	215 self.max_base = max_base;
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	216 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	217
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	218 /// Remove all ancestors of self.bases from the revs set (in place)
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	219 pub fn remove_ancestors_from(
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	220 &mut self,
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	221 revs: &mut HashSet<Revision>,
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	222 ) -> Result<(), GraphError> {
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	223 revs.retain(\|r\| !self.bases.contains(r));
41716 977432970080 rust: stop putting NULL_REVISION in MissingAncestors.bases Georges Racinet <georges.racinet@octobus.net> parents: 41715 diff changeset	224 // the null revision is always an ancestor. Logically speaking
977432970080 rust: stop putting NULL_REVISION in MissingAncestors.bases Georges Racinet <georges.racinet@octobus.net> parents: 41715 diff changeset	225 // it's debatable in case bases is empty, but the Python
977432970080 rust: stop putting NULL_REVISION in MissingAncestors.bases Georges Racinet <georges.racinet@octobus.net> parents: 41715 diff changeset	226 // implementation always adds NULL_REVISION to bases, making it
977432970080 rust: stop putting NULL_REVISION in MissingAncestors.bases Georges Racinet <georges.racinet@octobus.net> parents: 41715 diff changeset	227 // unconditionnally true.
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	228 revs.remove(&NULL_REVISION);
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	229 if revs.is_empty() {
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	230 return Ok(());
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	231 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	232 // anything in revs > start is definitely not an ancestor of bases
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	233 // revs <= start need to be investigated
41717 9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	234 if self.max_base == NULL_REVISION {
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	235 return Ok(());
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	236 }
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	237
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	238 // whatever happens, we'll keep at least keepcount of them
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	239 // knowing this gives us a earlier stop condition than
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	240 // going all the way to the root
41717 9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	241 let keepcount = revs.iter().filter(\|r\| **r > self.max_base).count();
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	242
41717 9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	243 let mut curr = self.max_base;
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	244 while curr != NULL_REVISION && revs.len() > keepcount {
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	245 if self.bases.contains(&curr) {
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	246 revs.remove(&curr);
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	247 self.add_parents(curr)?;
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	248 }
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	249 // We know this revision is safe because we've checked the bounds
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	250 // before.
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	251 curr = Revision(curr.0 - 1);
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	252 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	253 Ok(())
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	254 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	255
41717 9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	256 /// Add the parents of `rev` to `self.bases`
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	257 ///
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	258 /// This has no effect on `self.max_base`
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	259 #[inline]
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	260 fn add_parents(&mut self, rev: Revision) -> Result<(), GraphError> {
41717 9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	261 if rev == NULL_REVISION {
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	262 return Ok(());
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	263 }
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	264 for p in self.graph.parents(rev)?.iter().cloned() {
41717 9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	265 // No need to bother the set with inserting NULL_REVISION over and
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	266 // over
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	267 if p != NULL_REVISION {
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	268 self.bases.insert(p);
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	269 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	270 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	271 Ok(())
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	272 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	273
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	274 /// Return all the ancestors of revs that are not ancestors of self.bases
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	275 ///
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	276 /// This may include elements from revs.
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	277 ///
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	278 /// Equivalent to the revset (::revs - ::self.bases). Revs are returned in
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	279 /// revision number order, which is a topological order.
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	280 pub fn missing_ancestors(
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	281 &mut self,
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	282 revs: impl IntoIterator<Item = Revision>,
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	283 ) -> Result<Vec<Revision>, GraphError> {
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	284 // just for convenience and comparison with Python version
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	285 let bases_visit = &mut self.bases;
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	286 let mut revs: HashSet<Revision> = revs
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	287 .into_iter()
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	288 .filter(\|r\| !bases_visit.contains(r))
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	289 .collect();
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	290 let revs_visit = &mut revs;
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	291 let mut both_visit: HashSet<Revision> =
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49631 diff changeset	292 revs_visit.intersection(bases_visit).cloned().collect();
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	293 if revs_visit.is_empty() {
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	294 return Ok(Vec::new());
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	295 }
41717 9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	296 let max_revs = revs_visit.iter().cloned().max().unwrap();
9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	297 let start = max(self.max_base, max_revs);
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	298
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	299 // TODO heuristics for with_capacity()?
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	300 let mut missing: Vec<Revision> = Vec::new();
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	301 for curr in (0..=start.0).rev() {
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	302 if revs_visit.is_empty() {
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	303 break;
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	304 }
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	305 if both_visit.remove(&Revision(curr)) {
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	306 // curr's parents might have made it into revs_visit through
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	307 // another path
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	308 for p in self.graph.parents(Revision(curr))?.iter().cloned() {
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	309 if p == NULL_REVISION {
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	310 continue;
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	311 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	312 revs_visit.remove(&p);
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	313 bases_visit.insert(p);
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	314 both_visit.insert(p);
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	315 }
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	316 } else if revs_visit.remove(&Revision(curr)) {
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	317 missing.push(Revision(curr));
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	318 for p in self.graph.parents(Revision(curr))?.iter().cloned() {
41131 486908e691be rust-ancestors: adjust indent level to make next change easier to follow Yuya Nishihara <yuya@tcha.org> parents: 41105 diff changeset	319 if p == NULL_REVISION {
486908e691be rust-ancestors: adjust indent level to make next change easier to follow Yuya Nishihara <yuya@tcha.org> parents: 41105 diff changeset	320 continue;
486908e691be rust-ancestors: adjust indent level to make next change easier to follow Yuya Nishihara <yuya@tcha.org> parents: 41105 diff changeset	321 }
41715 fccb61a1777b rust: less set lookups in MissingAncestors Georges Racinet <georges.racinet@octobus.net> parents: 41714 diff changeset	322 if bases_visit.contains(&p) {
fccb61a1777b rust: less set lookups in MissingAncestors Georges Racinet <georges.racinet@octobus.net> parents: 41714 diff changeset	323 // p is already known to be an ancestor of revs_visit
fccb61a1777b rust: less set lookups in MissingAncestors Georges Racinet <georges.racinet@octobus.net> parents: 41714 diff changeset	324 revs_visit.remove(&p);
fccb61a1777b rust: less set lookups in MissingAncestors Georges Racinet <georges.racinet@octobus.net> parents: 41714 diff changeset	325 both_visit.insert(p);
fccb61a1777b rust: less set lookups in MissingAncestors Georges Racinet <georges.racinet@octobus.net> parents: 41714 diff changeset	326 } else if both_visit.contains(&p) {
fccb61a1777b rust: less set lookups in MissingAncestors Georges Racinet <georges.racinet@octobus.net> parents: 41714 diff changeset	327 // p should have been in bases_visit
41131 486908e691be rust-ancestors: adjust indent level to make next change easier to follow Yuya Nishihara <yuya@tcha.org> parents: 41105 diff changeset	328 revs_visit.remove(&p);
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	329 bases_visit.insert(p);
41131 486908e691be rust-ancestors: adjust indent level to make next change easier to follow Yuya Nishihara <yuya@tcha.org> parents: 41105 diff changeset	330 } else {
486908e691be rust-ancestors: adjust indent level to make next change easier to follow Yuya Nishihara <yuya@tcha.org> parents: 41105 diff changeset	331 // visit later
41133 a1b3800c8a19 rust-ancestors: remove unreachable conditions from missing_ancestors() Yuya Nishihara <yuya@tcha.org> parents: 41132 diff changeset	332 revs_visit.insert(p);
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	333 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	334 }
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	335 } else if bases_visit.contains(&Revision(curr)) {
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	336 for p in self.graph.parents(Revision(curr))?.iter().cloned() {
41132 55dc1da8df2f rust-ancestors: duplicate loop that visits parents of revs/bases Yuya Nishihara <yuya@tcha.org> parents: 41131 diff changeset	337 if p == NULL_REVISION {
55dc1da8df2f rust-ancestors: duplicate loop that visits parents of revs/bases Yuya Nishihara <yuya@tcha.org> parents: 41131 diff changeset	338 continue;
55dc1da8df2f rust-ancestors: duplicate loop that visits parents of revs/bases Yuya Nishihara <yuya@tcha.org> parents: 41131 diff changeset	339 }
41715 fccb61a1777b rust: less set lookups in MissingAncestors Georges Racinet <georges.racinet@octobus.net> parents: 41714 diff changeset	340 if revs_visit.remove(&p) \|\| both_visit.contains(&p) {
41134 17a195676472 rust-ancestors: adjust branches and inline comments per previous change Yuya Nishihara <yuya@tcha.org> parents: 41133 diff changeset	341 // p is an ancestor of bases_visit, and is implicitly
17a195676472 rust-ancestors: adjust branches and inline comments per previous change Yuya Nishihara <yuya@tcha.org> parents: 41133 diff changeset	342 // in revs_visit, which means p is ::revs & ::bases.
41132 55dc1da8df2f rust-ancestors: duplicate loop that visits parents of revs/bases Yuya Nishihara <yuya@tcha.org> parents: 41131 diff changeset	343 bases_visit.insert(p);
55dc1da8df2f rust-ancestors: duplicate loop that visits parents of revs/bases Yuya Nishihara <yuya@tcha.org> parents: 41131 diff changeset	344 both_visit.insert(p);
55dc1da8df2f rust-ancestors: duplicate loop that visits parents of revs/bases Yuya Nishihara <yuya@tcha.org> parents: 41131 diff changeset	345 } else {
41133 a1b3800c8a19 rust-ancestors: remove unreachable conditions from missing_ancestors() Yuya Nishihara <yuya@tcha.org> parents: 41132 diff changeset	346 bases_visit.insert(p);
41132 55dc1da8df2f rust-ancestors: duplicate loop that visits parents of revs/bases Yuya Nishihara <yuya@tcha.org> parents: 41131 diff changeset	347 }
55dc1da8df2f rust-ancestors: duplicate loop that visits parents of revs/bases Yuya Nishihara <yuya@tcha.org> parents: 41131 diff changeset	348 }
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	349 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	350 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	351 missing.reverse();
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	352 Ok(missing)
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	353 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	354 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	355
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	356 #[cfg(test)]
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	357 mod tests {
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	358
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	359 use super::*;
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	360 use crate::{
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	361 testing::{SampleGraph, VecGraph},
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	362 BaseRevision,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	363 };
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	364
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	365 impl From<BaseRevision> for Revision {
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	366 fn from(value: BaseRevision) -> Self {
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	367 if !cfg!(test) {
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	368 panic!("should only be used in tests")
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	369 }
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	370 Revision(value)
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	371 }
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	372 }
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	373
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	374 impl PartialEq<BaseRevision> for Revision {
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	375 fn eq(&self, other: &BaseRevision) -> bool {
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	376 if !cfg!(test) {
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	377 panic!("should only be used in tests")
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	378 }
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	379 self.0.eq(other)
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	380 }
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	381 }
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	382
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	383 impl PartialEq<u32> for Revision {
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	384 fn eq(&self, other: &u32) -> bool {
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	385 if !cfg!(test) {
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	386 panic!("should only be used in tests")
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	387 }
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	388 let check: Result<u32, _> = self.0.try_into();
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	389 match check {
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	390 Ok(value) => value.eq(other),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	391 Err(_) => false,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	392 }
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	393 }
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	394 }
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	395
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	396 fn list_ancestors<G: Graph>(
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	397 graph: G,
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	398 initrevs: Vec<Revision>,
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	399 stoprev: Revision,
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	400 inclusive: bool,
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	401 ) -> Vec<Revision> {
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	402 AncestorsIterator::new(graph, initrevs, stoprev, inclusive)
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	403 .unwrap()
40929 43ca24b772d6 rust: adapted hg-core tests for iteration over Result Georges Racinet <gracinet@anybox.fr> parents: 40927 diff changeset	404 .map(\|res\| res.unwrap())
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	405 .collect()
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	406 }
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	407
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	408 #[test]
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	409 /// Same tests as test-ancestor.py, without membership
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	410 /// (see also test-ancestor.py.out)
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	411 fn test_list_ancestor() {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	412 assert_eq!(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	413 list_ancestors(SampleGraph, vec![], 0.into(), false),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	414 Vec::<Revision>::new()
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	415 );
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	416 assert_eq!(
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	417 list_ancestors(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	418 SampleGraph,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	419 vec![11.into(), 13.into()],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	420 0.into(),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	421 false
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	422 ),
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	423 vec![8, 7, 4, 3, 2, 1, 0]
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	424 );
51616 b08c5fbe0e70 rust: blanket implementation of Graph for Graph references Georges Racinet <georges.racinet@octobus.net> parents: 50976 diff changeset	425 // it works as well on references, because &Graph implements Graph
b08c5fbe0e70 rust: blanket implementation of Graph for Graph references Georges Racinet <georges.racinet@octobus.net> parents: 50976 diff changeset	426 // this is needed as of this writing by RHGitaly
b08c5fbe0e70 rust: blanket implementation of Graph for Graph references Georges Racinet <georges.racinet@octobus.net> parents: 50976 diff changeset	427 assert_eq!(
b08c5fbe0e70 rust: blanket implementation of Graph for Graph references Georges Racinet <georges.racinet@octobus.net> parents: 50976 diff changeset	428 list_ancestors(
b08c5fbe0e70 rust: blanket implementation of Graph for Graph references Georges Racinet <georges.racinet@octobus.net> parents: 50976 diff changeset	429 &SampleGraph,
b08c5fbe0e70 rust: blanket implementation of Graph for Graph references Georges Racinet <georges.racinet@octobus.net> parents: 50976 diff changeset	430 vec![11.into(), 13.into()],
b08c5fbe0e70 rust: blanket implementation of Graph for Graph references Georges Racinet <georges.racinet@octobus.net> parents: 50976 diff changeset	431 0.into(),
b08c5fbe0e70 rust: blanket implementation of Graph for Graph references Georges Racinet <georges.racinet@octobus.net> parents: 50976 diff changeset	432 false
b08c5fbe0e70 rust: blanket implementation of Graph for Graph references Georges Racinet <georges.racinet@octobus.net> parents: 50976 diff changeset	433 ),
b08c5fbe0e70 rust: blanket implementation of Graph for Graph references Georges Racinet <georges.racinet@octobus.net> parents: 50976 diff changeset	434 vec![8, 7, 4, 3, 2, 1, 0]
b08c5fbe0e70 rust: blanket implementation of Graph for Graph references Georges Racinet <georges.racinet@octobus.net> parents: 50976 diff changeset	435 );
b08c5fbe0e70 rust: blanket implementation of Graph for Graph references Georges Racinet <georges.racinet@octobus.net> parents: 50976 diff changeset	436
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	437 assert_eq!(
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	438 list_ancestors(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	439 SampleGraph,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	440 vec![1.into(), 3.into()],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	441 0.into(),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	442 false
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	443 ),
41241 168041fa6d5f rust: factorized testing Graphs Georges Racinet <georges.racinet@octobus.net> parents: 41134 diff changeset	444 vec![1, 0]
168041fa6d5f rust: factorized testing Graphs Georges Racinet <georges.racinet@octobus.net> parents: 41134 diff changeset	445 );
168041fa6d5f rust: factorized testing Graphs Georges Racinet <georges.racinet@octobus.net> parents: 41134 diff changeset	446 assert_eq!(
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	447 list_ancestors(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	448 SampleGraph,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	449 vec![11.into(), 13.into()],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	450 0.into(),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	451 true
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	452 ),
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	453 vec![13, 11, 8, 7, 4, 3, 2, 1, 0]
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	454 );
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	455 assert_eq!(
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	456 list_ancestors(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	457 SampleGraph,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	458 vec![11.into(), 13.into()],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	459 6.into(),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	460 false
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	461 ),
41241 168041fa6d5f rust: factorized testing Graphs Georges Racinet <georges.racinet@octobus.net> parents: 41134 diff changeset	462 vec![8, 7]
168041fa6d5f rust: factorized testing Graphs Georges Racinet <georges.racinet@octobus.net> parents: 41134 diff changeset	463 );
168041fa6d5f rust: factorized testing Graphs Georges Racinet <georges.racinet@octobus.net> parents: 41134 diff changeset	464 assert_eq!(
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	465 list_ancestors(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	466 SampleGraph,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	467 vec![11.into(), 13.into()],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	468 6.into(),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	469 true
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	470 ),
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	471 vec![13, 11, 8, 7]
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	472 );
41241 168041fa6d5f rust: factorized testing Graphs Georges Racinet <georges.racinet@octobus.net> parents: 41134 diff changeset	473 assert_eq!(
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	474 list_ancestors(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	475 SampleGraph,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	476 vec![11.into(), 13.into()],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	477 11.into(),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	478 true
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	479 ),
41241 168041fa6d5f rust: factorized testing Graphs Georges Racinet <georges.racinet@octobus.net> parents: 41134 diff changeset	480 vec![13, 11]
168041fa6d5f rust: factorized testing Graphs Georges Racinet <georges.racinet@octobus.net> parents: 41134 diff changeset	481 );
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	482 assert_eq!(
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	483 list_ancestors(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	484 SampleGraph,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	485 vec![11.into(), 13.into()],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	486 12.into(),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	487 true
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	488 ),
41241 168041fa6d5f rust: factorized testing Graphs Georges Racinet <georges.racinet@octobus.net> parents: 41134 diff changeset	489 vec![13]
168041fa6d5f rust: factorized testing Graphs Georges Racinet <georges.racinet@octobus.net> parents: 41134 diff changeset	490 );
168041fa6d5f rust: factorized testing Graphs Georges Racinet <georges.racinet@octobus.net> parents: 41134 diff changeset	491 assert_eq!(
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	492 list_ancestors(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	493 SampleGraph,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	494 vec![10.into(), 1.into()],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	495 0.into(),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	496 true
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	497 ),
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	498 vec![10, 5, 4, 2, 1, 0]
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	499 );
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	500 }
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	501
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	502 #[test]
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	503 /// Corner case that's not directly in test-ancestors.py, but
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	504 /// that happens quite often, as demonstrated by running the whole
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	505 /// suite.
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	506 /// For instance, run tests/test-obsolete-checkheads.t
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	507 fn test_nullrev_input() {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	508 let mut iter = AncestorsIterator::new(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	509 SampleGraph,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	510 vec![Revision(-1)],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	511 0.into(),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	512 false,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	513 )
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	514 .unwrap();
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	515 assert_eq!(iter.next(), None)
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	516 }
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	517
40300 72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40271 diff changeset	518 #[test]
72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40271 diff changeset	519 fn test_contains() {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	520 let mut lazy = AncestorsIterator::new(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	521 SampleGraph,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	522 vec![10.into(), 1.into()],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	523 0.into(),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	524 true,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	525 )
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	526 .unwrap();
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	527 assert!(lazy.contains(1.into()).unwrap());
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	528 assert!(!lazy.contains(3.into()).unwrap());
40300 72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40271 diff changeset	529
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	530 let mut lazy = AncestorsIterator::new(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	531 SampleGraph,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	532 vec![0.into()],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	533 0.into(),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	534 false,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	535 )
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	536 .unwrap();
40929 43ca24b772d6 rust: adapted hg-core tests for iteration over Result Georges Racinet <gracinet@anybox.fr> parents: 40927 diff changeset	537 assert!(!lazy.contains(NULL_REVISION).unwrap());
40300 72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40271 diff changeset	538 }
72b94f946e90 rust: rustlazyancestors.__contains__ Georges Racinet <gracinet@anybox.fr> parents: 40271 diff changeset	539
41054 ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	540 #[test]
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	541 fn test_peek() {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	542 let mut iter = AncestorsIterator::new(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	543 SampleGraph,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	544 vec![10.into()],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	545 0.into(),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	546 true,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	547 )
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	548 .unwrap();
41054 ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	549 // peek() gives us the next value
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	550 assert_eq!(iter.peek(), Some(10.into()));
41054 ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	551 // but it's not been consumed
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	552 assert_eq!(iter.next(), Some(Ok(10.into())));
41054 ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	553 // and iteration resumes normally
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	554 assert_eq!(iter.next(), Some(Ok(5.into())));
41054 ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	555
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	556 // let's drain the iterator to test peek() at the end
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	557 while iter.next().is_some() {}
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	558 assert_eq!(iter.peek(), None);
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	559 }
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	560
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	561 #[test]
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	562 fn test_empty() {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	563 let mut iter = AncestorsIterator::new(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	564 SampleGraph,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	565 vec![10.into()],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	566 0.into(),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	567 true,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	568 )
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	569 .unwrap();
41054 ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	570 assert!(!iter.is_empty());
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	571 while iter.next().is_some() {}
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	572 assert!(!iter.is_empty());
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	573
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	574 let iter = AncestorsIterator::new(SampleGraph, vec![], 0.into(), true)
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	575 .unwrap();
41054 ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	576 assert!(iter.is_empty());
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	577
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	578 // case where iter.seen == {NULL_REVISION}
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	579 let iter = AncestorsIterator::new(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	580 SampleGraph,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	581 vec![0.into()],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	582 0.into(),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	583 false,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	584 )
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	585 .unwrap();
41054 ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	586 assert!(iter.is_empty());
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	587 }
ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	588
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	589 /// A corrupted Graph, supporting error handling tests
41054 ef54bd33b476 rust: core implementation for lazyancestors Georges Racinet <gracinet@anybox.fr> parents: 40959 diff changeset	590 #[derive(Clone, Debug)]
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	591 struct Corrupted;
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	592
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	593 impl Graph for Corrupted {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	594 // FIXME what to do about this? Are we just not supposed to get them
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	595 // anymore?
40933 18513d6ef7d4 rust: changed Graph.parents to return [Revision; 2] Georges Racinet <gracinet@anybox.fr> parents: 40932 diff changeset	596 fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> {
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	597 match rev {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	598 Revision(1) => Ok([0.into(), (-1).into()]),
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	599 r => Err(GraphError::ParentOutOfRange(r)),
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	600 }
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	601 }
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	602 }
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	603
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	604 #[test]
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	605 fn test_initrev_out_of_range() {
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	606 // inclusive=false looks up initrev's parents right away
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	607 match AncestorsIterator::new(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	608 SampleGraph,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	609 vec![25.into()],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	610 0.into(),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	611 false,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	612 ) {
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	613 Ok(_) => panic!("Should have been ParentOutOfRange"),
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	614 Err(e) => assert_eq!(e, GraphError::ParentOutOfRange(25.into())),
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	615 }
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	616 }
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	617
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	618 #[test]
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	619 fn test_next_out_of_range() {
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	620 // inclusive=false looks up initrev's parents right away
dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	621 let mut iter =
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	622 AncestorsIterator::new(Corrupted, vec![1.into()], 0.into(), false)
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	623 .unwrap();
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	624 assert_eq!(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	625 iter.next(),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	626 Some(Err(GraphError::ParentOutOfRange(0.into())))
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	627 );
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	628 }
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	629
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	630 #[test]
41246 619ee4039bd4 rust: MissingAncestors.basesheads() Georges Racinet <georges.racinet@octobus.net> parents: 41241 diff changeset	631 /// Test constructor, add/get bases and heads
619ee4039bd4 rust: MissingAncestors.basesheads() Georges Racinet <georges.racinet@octobus.net> parents: 41241 diff changeset	632 fn test_missing_bases() -> Result<(), GraphError> {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	633 let mut missing_ancestors = MissingAncestors::new(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	634 SampleGraph,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	635 [5.into(), 3.into(), 1.into(), 3.into()].iter().cloned(),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	636 );
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	637 let mut as_vec: Vec<Revision> =
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	638 missing_ancestors.get_bases().iter().cloned().collect();
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49631 diff changeset	639 as_vec.sort_unstable();
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	640 assert_eq!(as_vec, [1, 3, 5]);
41717 9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	641 assert_eq!(missing_ancestors.max_base, 5);
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	642
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	643 missing_ancestors
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	644 .add_bases([3.into(), 7.into(), 8.into()].iter().cloned());
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	645 as_vec = missing_ancestors.get_bases().iter().cloned().collect();
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49631 diff changeset	646 as_vec.sort_unstable();
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	647 assert_eq!(as_vec, [1, 3, 5, 7, 8]);
41717 9060af281be7 rust: itering less on MissingAncestors.bases for max() Georges Racinet <georges.racinet@octobus.net> parents: 41716 diff changeset	648 assert_eq!(missing_ancestors.max_base, 8);
41246 619ee4039bd4 rust: MissingAncestors.basesheads() Georges Racinet <georges.racinet@octobus.net> parents: 41241 diff changeset	649
619ee4039bd4 rust: MissingAncestors.basesheads() Georges Racinet <georges.racinet@octobus.net> parents: 41241 diff changeset	650 as_vec = missing_ancestors.bases_heads()?.iter().cloned().collect();
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49631 diff changeset	651 as_vec.sort_unstable();
41246 619ee4039bd4 rust: MissingAncestors.basesheads() Georges Racinet <georges.racinet@octobus.net> parents: 41241 diff changeset	652 assert_eq!(as_vec, [3, 5, 7, 8]);
619ee4039bd4 rust: MissingAncestors.basesheads() Georges Racinet <georges.racinet@octobus.net> parents: 41241 diff changeset	653 Ok(())
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	654 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	655
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	656 fn assert_missing_remove(
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	657 bases: &[BaseRevision],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	658 revs: &[BaseRevision],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	659 expected: &[BaseRevision],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	660 ) {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	661 let mut missing_ancestors = MissingAncestors::new(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	662 SampleGraph,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	663 bases.iter().map(\|r\| Revision(*r)),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	664 );
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	665 let mut revset: HashSet<Revision> =
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	666 revs.iter().map(\|r\| Revision(*r)).collect();
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	667 missing_ancestors
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	668 .remove_ancestors_from(&mut revset)
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	669 .unwrap();
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	670 let mut as_vec: Vec<Revision> = revset.into_iter().collect();
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49631 diff changeset	671 as_vec.sort_unstable();
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	672 assert_eq!(as_vec.as_slice(), expected);
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	673 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	674
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	675 #[test]
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	676 fn test_missing_remove() {
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	677 assert_missing_remove(
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	678 &[1, 2, 3, 4, 7],
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	679 Vec::from_iter(1..10).as_slice(),
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	680 &[5, 6, 8, 9],
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	681 );
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	682 assert_missing_remove(&[10], &[11, 12, 13, 14], &[11, 12, 13, 14]);
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	683 assert_missing_remove(&[7], &[1, 2, 3, 4, 5], &[3, 5]);
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	684 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	685
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	686 fn assert_missing_ancestors(
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	687 bases: &[BaseRevision],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	688 revs: &[BaseRevision],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	689 expected: &[BaseRevision],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	690 ) {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	691 let mut missing_ancestors = MissingAncestors::new(
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	692 SampleGraph,
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	693 bases.iter().map(\|r\| Revision(*r)),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	694 );
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	695 let missing = missing_ancestors
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	696 .missing_ancestors(revs.iter().map(\|r\| Revision(*r)))
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	697 .unwrap();
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	698 assert_eq!(missing.as_slice(), expected);
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	699 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	700
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	701 #[test]
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	702 fn test_missing_ancestors() {
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	703 // examples taken from test-ancestors.py by having it run
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	704 // on the same graph (both naive and fast Python algs)
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	705 assert_missing_ancestors(&[10], &[11], &[3, 7, 11]);
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	706 assert_missing_ancestors(&[11], &[10], &[5, 10]);
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	707 assert_missing_ancestors(&[7], &[9, 11], &[3, 6, 9, 11]);
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	708 }
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	709
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	710 /// An interesting case found by a random generator similar to
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	711 /// the one in test-ancestor.py. An early version of Rust MissingAncestors
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	712 /// failed this, yet none of the integration tests of the whole suite
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	713 /// catched it.
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49631 diff changeset	714 #[allow(clippy::unnecessary_cast)]
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	715 #[test]
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	716 fn test_remove_ancestors_from_case1() {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	717 const FAKE_NULL_REVISION: BaseRevision = -1;
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	718 assert_eq!(FAKE_NULL_REVISION, NULL_REVISION.0);
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	719 let graph: VecGraph = vec![
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	720 [FAKE_NULL_REVISION, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	721 [0, FAKE_NULL_REVISION],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	722 [1, 0],
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	723 [2, 1],
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	724 [3, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	725 [4, FAKE_NULL_REVISION],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	726 [5, 1],
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	727 [2, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	728 [7, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	729 [8, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	730 [9, FAKE_NULL_REVISION],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	731 [10, 1],
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	732 [3, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	733 [12, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	734 [13, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	735 [14, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	736 [4, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	737 [16, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	738 [17, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	739 [18, FAKE_NULL_REVISION],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	740 [19, 11],
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	741 [20, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	742 [21, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	743 [22, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	744 [23, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	745 [2, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	746 [3, FAKE_NULL_REVISION],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	747 [26, 24],
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	748 [27, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	749 [28, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	750 [12, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	751 [1, FAKE_NULL_REVISION],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	752 [1, 9],
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	753 [32, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	754 [33, FAKE_NULL_REVISION],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	755 [34, 31],
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	756 [35, FAKE_NULL_REVISION],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	757 [36, 26],
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	758 [37, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	759 [38, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	760 [39, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	761 [40, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	762 [41, FAKE_NULL_REVISION],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	763 [42, 26],
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	764 [0, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	765 [44, FAKE_NULL_REVISION],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	766 [45, 4],
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	767 [40, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	768 [47, FAKE_NULL_REVISION],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	769 [36, 0],
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	770 [49, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	771 [FAKE_NULL_REVISION, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	772 [51, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	773 [52, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	774 [53, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	775 [14, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	776 [55, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	777 [15, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	778 [23, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	779 [58, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	780 [59, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	781 [2, FAKE_NULL_REVISION],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	782 [61, 59],
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	783 [62, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	784 [63, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	785 [FAKE_NULL_REVISION, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	786 [65, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	787 [66, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	788 [67, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	789 [68, FAKE_NULL_REVISION],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	790 [37, 28],
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	791 [69, 25],
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	792 [71, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	793 [72, FAKE_NULL_REVISION],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	794 [50, 2],
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	795 [74, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	796 [12, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	797 [18, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	798 [77, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	799 [78, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	800 [79, FAKE_NULL_REVISION],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	801 [43, 33],
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	802 [81, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	803 [82, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	804 [83, FAKE_NULL_REVISION],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	805 [84, 45],
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	806 [85, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	807 [86, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	808 [FAKE_NULL_REVISION, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	809 [88, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	810 [FAKE_NULL_REVISION, FAKE_NULL_REVISION],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	811 [76, 83],
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	812 [44, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	813 [92, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	814 [93, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	815 [9, FAKE_NULL_REVISION],
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	816 [95, 67],
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	817 [96, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	818 [97, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	819 [FAKE_NULL_REVISION, FAKE_NULL_REVISION],
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	820 ]
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	821 .into_iter()
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	822 .map(\|[a, b]\| [Revision(a), Revision(b)])
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	823 .collect();
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	824 let problem_rev = 28.into();
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	825 let problem_base = 70.into();
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	826 // making the problem obvious: problem_rev is a parent of problem_base
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	827 assert_eq!(graph.parents(problem_base).unwrap()[1], problem_rev);
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	828
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	829 let mut missing_ancestors: MissingAncestors<VecGraph> =
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	830 MissingAncestors::new(
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	831 graph,
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	832 [60, 26, 70, 3, 96, 19, 98, 49, 97, 47, 1, 6]
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	833 .iter()
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	834 .map(\|r\| Revision(*r)),
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	835 );
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	836 assert!(missing_ancestors.bases.contains(&problem_base));
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	837
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	838 let mut revs: HashSet<Revision> =
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	839 [4, 12, 41, 28, 68, 38, 1, 30, 56, 44]
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	840 .iter()
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	841 .map(\|r\| Revision(*r))
40959 d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	842 .collect();
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	843 missing_ancestors.remove_ancestors_from(&mut revs).unwrap();
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	844 assert!(!revs.contains(&problem_rev));
d097dd0afc19 rust: translation of missingancestors Georges Racinet <gracinet@anybox.fr> parents: 40933 diff changeset	845 }
40271 dbc28c91f7ff rust: pure Rust lazyancestors iterator Georges Racinet <gracinet@anybox.fr> parents: diff changeset	846 }

Mercurial > public > mercurial-scm > hg

annotate rust/hg-core/src/ancestors.rs @ 52300:04b9a56c2d25