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

annotate rust/hg-core/src/ancestors.rs @ 53042:cdd7bf612c7b stable tip

bundle-spec: properly format boolean parameter (issue6960) This was breaking automatic clone bundle generation. This changeset fixes it and add a test to catch it in the future.

author	Pierre-Yves David <pierre-yves.david@octobus.net>
date	Tue, 11 Mar 2025 02:29:42 +0100
parents	e9ced84aeef4
children

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

Mercurial > public > mercurial-scm > hg

annotate rust/hg-core/src/ancestors.rs @ 53042:cdd7bf612c7b stable tip