This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7720

rust-discovery: moved some methods to the wrapper enum
Needs RevisionPublic

Authored by gracinet on Dec 24 2019, 8:50 AM.

Details

Reviewers
Alphare
baymax
Group Reviewers
hg-reviewers
Summary

In the primary switch to the typestate pattern, these
methods have been kept on the WithUndecided struct, that
had most of the original methods of PartialDiscovery, so
that the change would be readable.

But we feel it makes more sense to have them on the wrapper
enum.

common_heads would also be a candidate for a last stage method,
we wouldn't need that lenghty warning docstring that it's not
relevant if is-complete is true

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

gracinet created this revision.Dec 24 2019, 8:50 AM
Alphare accepted this revision.Jan 3 2020, 4:54 AM
baymax requested changes to this revision.Apr 22 2020, 11:52 AM

There seems to have been no activities on this Diff for the past 3 Months.

By policy, we are automatically moving it out of the need-review state.

Please, move it back to need-review without hesitation if this diff should still be discussed.

:baymax:need-review-idle:

This revision now requires changes to proceed.Apr 22 2020, 11:52 AM

Revision Contents
Changeset List

PathPackages
Mrust/hg-core/src/discovery.rs (44 lines)

Diff 18928

rust/hg-core/src/discovery.rs

graph, graph,
target_heads, target_heads,
seed, seed,
respect_size, respect_size,
randomize, randomize,
)) ))
} }
/// Do we have any information about the peer? fn get_common(&self) -> &MissingAncestors<G> {
pub fn has_info(&self) -> bool {
match self { match self {
Com(c) => c.common.has_bases(), Com(c) => &c.common,
Und(u) => u.has_info(), Und(u) => &u.common,
} }
} }
/// Do we have any information about the peer?
pub fn has_info(&self) -> bool {
self.get_common().has_bases()
}
/// Did we acquire full knowledge of our Revisions that the peer has? /// Did we acquire full knowledge of our Revisions that the peer has?
pub fn is_complete(&self) -> bool { pub fn is_complete(&self) -> bool {
match self { match self {
Com(_) => false, Com(_) => false,
Und(u) => u.is_complete(), Und(u) => u.undecided.is_empty(),
} }
} }
/// Return the heads of the currently known common set of revisions. /// Return the heads of the currently known common set of revisions.
/// ///
/// If the discovery process is not complete (see `is_complete()`), the /// If the discovery process is not complete (see `is_complete()`), the
/// caller must be aware that this is an intermediate state. /// caller must be aware that this is an intermediate state.
/// ///
/// On the other hand, if it is complete, then this is currently /// On the other hand, if it is complete, then this is currently
/// the only way to retrieve the end results of the discovery process. /// the only way to retrieve the end results of the discovery process.
/// ///
/// We may introduce in the future an `into_common_heads` call that /// We may introduce in the future an `into_common_heads` call that
/// would be more appropriate for normal Rust callers, dropping `self` /// would be more appropriate for normal Rust callers, dropping `self`
/// if it is complete. /// if it is complete.
pub fn common_heads(&self) -> Result<HashSet<Revision>, GraphError> { pub fn common_heads(&self) -> Result<HashSet<Revision>, GraphError> {
match self { self.get_common().bases_heads()
Com(c) => c.common.bases_heads(),
Und(u) => u.common_heads(),
}
} }
/// Provide statistics about the current state of the discovery process /// Provide statistics about the current state of the discovery process
pub fn stats(&self) -> DiscoveryStats { pub fn stats(&self) -> DiscoveryStats {
match self { match self {
Com(c) => c.stats(), Com(c) => c.stats(),
Und(u) => u.stats(), Und(u) => u.stats(),
} }
} }
} }
} }
} }
} }
Ok(()) Ok(())
} }
/// Do we have any information about the peer?
pub fn has_info(&self) -> bool {
self.common.has_bases()
}
/// Did we acquire full knowledge of our Revisions that the peer has?
pub fn is_complete(&self) -> bool {
self.undecided.is_empty()
}
/// Return the heads of the currently known common set of revisions.
///
/// If the discovery process is not complete (see `is_complete()`), the
/// caller must be aware that this is an intermediate state.
///
/// On the other hand, if it is complete, then this is currently
/// the only way to retrieve the end results of the discovery process.
///
/// We may introduce in the future an `into_common_heads` call that
/// would be more appropriate for normal Rust callers, dropping `self`
/// if it is complete.
pub fn common_heads(&self) -> Result<HashSet<Revision>, GraphError> {
self.common.bases_heads()
}
fn compute_children_cache( fn compute_children_cache(
graph: &G, graph: &G,
undecided: impl Iterator<Item = Revision>, undecided: impl Iterator<Item = Revision>,
) -> Result<(FastHashMap<Revision, Vec<Revision>>), GraphError> { ) -> Result<(FastHashMap<Revision, Vec<Revision>>), GraphError> {
let mut children: FastHashMap<Revision, Vec<Revision>> = let mut children: FastHashMap<Revision, Vec<Revision>> =
FastHashMap::default(); FastHashMap::default();
for rev in undecided.into_iter() { for rev in undecided.into_iter() {
for p in ParentsIterator::graph_parents(graph, rev)? { for p in ParentsIterator::graph_parents(graph, rev)? {