We are looking into moving away from TimeStampedPathCopy (that use is_ancestors
call to detect overwrite) in favor of an approach that does not requires
is_ancestors calls. Yet we will still need an internal representation that
differs from the returned result.
So we call it "InternalPathCopies" which is generic but clear.
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| Path | Packages | |||
|---|---|---|---|---|
| M | rust/hg-core/src/copy_tracing.rs (30 lines) |
| /// revision at which the copy information was added | /// revision at which the copy information was added | ||||
| rev: Revision, | rev: Revision, | ||||
| /// the copy source, (Set to None in case of deletion of the associated | /// the copy source, (Set to None in case of deletion of the associated | ||||
| /// key) | /// key) | ||||
| path: Option<PathToken>, | path: Option<PathToken>, | ||||
| } | } | ||||
| /// maps CopyDestination to Copy Source (+ a "timestamp" for the operation) | /// maps CopyDestination to Copy Source (+ a "timestamp" for the operation) | ||||
| type TimeStampedPathCopies = OrdMap<PathToken, TimeStampedPathCopy>; | type InternalPathCopies = OrdMap<PathToken, TimeStampedPathCopy>; | ||||
| /// hold parent 1, parent 2 and relevant files actions. | /// hold parent 1, parent 2 and relevant files actions. | ||||
| pub type RevInfo<'a> = (Revision, Revision, ChangedFiles<'a>); | pub type RevInfo<'a> = (Revision, Revision, ChangedFiles<'a>); | ||||
| /// represent the files affected by a changesets | /// represent the files affected by a changesets | ||||
| /// | /// | ||||
| /// This hold a subset of mercurial.metadata.ChangingFiles as we do not need | /// This hold a subset of mercurial.metadata.ChangingFiles as we do not need | ||||
| /// all the data categories tracked by it. | /// all the data categories tracked by it. | ||||
| for rev in revs { | for rev in revs { | ||||
| let mut d: DataHolder<D> = DataHolder { data: None }; | let mut d: DataHolder<D> = DataHolder { data: None }; | ||||
| let (p1, p2, changes) = rev_info(rev, &mut d); | let (p1, p2, changes) = rev_info(rev, &mut d); | ||||
| // We will chain the copies information accumulated for the parent with | // We will chain the copies information accumulated for the parent with | ||||
| // the individual copies information the curent revision. Creating a | // the individual copies information the curent revision. Creating a | ||||
| // new TimeStampedPath for each `rev` → `children` vertex. | // new TimeStampedPath for each `rev` → `children` vertex. | ||||
| let mut copies: Option<TimeStampedPathCopies> = None; | let mut copies: Option<InternalPathCopies> = None; | ||||
| if p1 != NULL_REVISION { | if p1 != NULL_REVISION { | ||||
| // Retrieve data computed in a previous iteration | // Retrieve data computed in a previous iteration | ||||
| let parent_copies = get_and_clean_parent_copies( | let parent_copies = get_and_clean_parent_copies( | ||||
| &mut all_copies, | &mut all_copies, | ||||
| &mut children_count, | &mut children_count, | ||||
| p1, | p1, | ||||
| ); | ); | ||||
| if let Some(parent_copies) = parent_copies { | if let Some(parent_copies) = parent_copies { | ||||
| /// fetch previous computed information | /// fetch previous computed information | ||||
| /// | /// | ||||
| /// If no other children are expected to need this information, we drop it from | /// If no other children are expected to need this information, we drop it from | ||||
| /// the cache. | /// the cache. | ||||
| /// | /// | ||||
| /// If parent is not part of the set we are expected to walk, return None. | /// If parent is not part of the set we are expected to walk, return None. | ||||
| fn get_and_clean_parent_copies( | fn get_and_clean_parent_copies( | ||||
| all_copies: &mut HashMap<Revision, TimeStampedPathCopies>, | all_copies: &mut HashMap<Revision, InternalPathCopies>, | ||||
| children_count: &mut HashMap<Revision, usize>, | children_count: &mut HashMap<Revision, usize>, | ||||
| parent_rev: Revision, | parent_rev: Revision, | ||||
| ) -> Option<TimeStampedPathCopies> { | ) -> Option<InternalPathCopies> { | ||||
| let count = children_count.get_mut(&parent_rev)?; | let count = children_count.get_mut(&parent_rev)?; | ||||
| *count -= 1; | *count -= 1; | ||||
| if *count == 0 { | if *count == 0 { | ||||
| match all_copies.remove(&parent_rev) { | match all_copies.remove(&parent_rev) { | ||||
| Some(c) => Some(c), | Some(c) => Some(c), | ||||
| None => Some(TimeStampedPathCopies::default()), | None => Some(InternalPathCopies::default()), | ||||
| } | } | ||||
| } else { | } else { | ||||
| match all_copies.get(&parent_rev) { | match all_copies.get(&parent_rev) { | ||||
| Some(c) => Some(c.clone()), | Some(c) => Some(c.clone()), | ||||
| None => Some(TimeStampedPathCopies::default()), | None => Some(InternalPathCopies::default()), | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| /// Combine ChangedFiles with some existing PathCopies information and return | /// Combine ChangedFiles with some existing PathCopies information and return | ||||
| /// the result | /// the result | ||||
| fn add_from_changes<A: Fn(Revision, Revision) -> bool>( | fn add_from_changes<A: Fn(Revision, Revision) -> bool>( | ||||
| path_map: &mut TwoWayPathMap, | path_map: &mut TwoWayPathMap, | ||||
| oracle: &mut AncestorOracle<A>, | oracle: &mut AncestorOracle<A>, | ||||
| base_copies: &TimeStampedPathCopies, | base_copies: &InternalPathCopies, | ||||
| changes: &ChangedFiles, | changes: &ChangedFiles, | ||||
| parent: Parent, | parent: Parent, | ||||
| current_rev: Revision, | current_rev: Revision, | ||||
| ) -> TimeStampedPathCopies { | ) -> InternalPathCopies { | ||||
| let mut copies = base_copies.clone(); | let mut copies = base_copies.clone(); | ||||
| for action in changes.iter_actions(parent) { | for action in changes.iter_actions(parent) { | ||||
| match action { | match action { | ||||
| Action::Copied(path_dest, path_source) => { | Action::Copied(path_dest, path_source) => { | ||||
| let dest = path_map.tokenize(path_dest); | let dest = path_map.tokenize(path_dest); | ||||
| let source = path_map.tokenize(path_source); | let source = path_map.tokenize(path_source); | ||||
| let entry; | let entry; | ||||
| if let Some(v) = base_copies.get(&source) { | if let Some(v) = base_copies.get(&source) { | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| Action::Removed(deleted_path) => { | Action::Removed(deleted_path) => { | ||||
| // We must drop copy information for removed file. | // We must drop copy information for removed file. | ||||
| // | // | ||||
| // We need to explicitly record them as dropped to | // We need to explicitly record them as dropped to | ||||
| // propagate this information when merging two | // propagate this information when merging two | ||||
| // TimeStampedPathCopies object. | // InternalPathCopies object. | ||||
| let deleted = path_map.tokenize(deleted_path); | let deleted = path_map.tokenize(deleted_path); | ||||
| copies.entry(deleted).and_modify(|old| { | copies.entry(deleted).and_modify(|old| { | ||||
| oracle.record_overwrite(old.rev, current_rev); | oracle.record_overwrite(old.rev, current_rev); | ||||
| old.rev = current_rev; | old.rev = current_rev; | ||||
| old.path = None; | old.path = None; | ||||
| }); | }); | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| copies | copies | ||||
| } | } | ||||
| /// merge two copies-mapping together, minor and major | /// merge two copies-mapping together, minor and major | ||||
| /// | /// | ||||
| /// In case of conflict, value from "major" will be picked, unless in some | /// In case of conflict, value from "major" will be picked, unless in some | ||||
| /// cases. See inline documentation for details. | /// cases. See inline documentation for details. | ||||
| fn merge_copies_dict<A: Fn(Revision, Revision) -> bool>( | fn merge_copies_dict<A: Fn(Revision, Revision) -> bool>( | ||||
| path_map: &TwoWayPathMap, | path_map: &TwoWayPathMap, | ||||
| current_merge: Revision, | current_merge: Revision, | ||||
| mut minor: TimeStampedPathCopies, | mut minor: InternalPathCopies, | ||||
| mut major: TimeStampedPathCopies, | mut major: InternalPathCopies, | ||||
| changes: &ChangedFiles, | changes: &ChangedFiles, | ||||
| oracle: &mut AncestorOracle<A>, | oracle: &mut AncestorOracle<A>, | ||||
| ) -> TimeStampedPathCopies { | ) -> InternalPathCopies { | ||||
| // This closure exist as temporary help while multiple developper are | // This closure exist as temporary help while multiple developper are | ||||
| // actively working on this code. Feel free to re-inline it once this | // actively working on this code. Feel free to re-inline it once this | ||||
| // code is more settled. | // code is more settled. | ||||
| let cmp_value = |oracle: &mut AncestorOracle<A>, | let cmp_value = |oracle: &mut AncestorOracle<A>, | ||||
| dest: &PathToken, | dest: &PathToken, | ||||
| src_minor: &TimeStampedPathCopy, | src_minor: &TimeStampedPathCopy, | ||||
| src_major: &TimeStampedPathCopy| { | src_major: &TimeStampedPathCopy| { | ||||
| compare_value( | compare_value( | ||||
| path_map, | path_map, | ||||
| current_merge, | current_merge, | ||||
| changes, | changes, | ||||
| oracle, | oracle, | ||||
| dest, | dest, | ||||
| src_minor, | src_minor, | ||||
| src_major, | src_major, | ||||
| ) | ) | ||||
| }; | }; | ||||
| if minor.is_empty() { | if minor.is_empty() { | ||||
| major | major | ||||
| } else if major.is_empty() { | } else if major.is_empty() { | ||||
| minor | minor | ||||
| } else if minor.len() * 2 < major.len() { | } else if minor.len() * 2 < major.len() { | ||||
| // Lets says we are merging two TimeStampedPathCopies instance A and B. | // Lets says we are merging two InternalPathCopies instance A and B. | ||||
| // | // | ||||
| // If A contains N items, the merge result will never contains more | // If A contains N items, the merge result will never contains more | ||||
| // than N values differents than the one in A | // than N values differents than the one in A | ||||
| // | // | ||||
| // If B contains M items, with M > N, the merge result will always | // If B contains M items, with M > N, the merge result will always | ||||
| // result in a minimum of M - N value differents than the on in | // result in a minimum of M - N value differents than the on in | ||||
| // A | // A | ||||
| // | // | ||||
| // As a result, if N < (M-N), we know that simply iterating over A will | // As a result, if N < (M-N), we know that simply iterating over A will | ||||
| // yield less difference than iterating over the difference | // yield less difference than iterating over the difference | ||||
| // between A and B. | // between A and B. | ||||
| // | // | ||||
| // This help performance a lot in case were a tiny | // This help performance a lot in case were a tiny | ||||
| // TimeStampedPathCopies is merged with a much larger one. | // InternalPathCopies is merged with a much larger one. | ||||
| for (dest, src_minor) in minor { | for (dest, src_minor) in minor { | ||||
| let src_major = major.get(&dest); | let src_major = major.get(&dest); | ||||
| match src_major { | match src_major { | ||||
| None => { | None => { | ||||
| major.insert(dest, src_minor); | major.insert(dest, src_minor); | ||||
| } | } | ||||
| Some(src_major) => { | Some(src_major) => { | ||||
| let (pick, overwrite) = | let (pick, overwrite) = | ||||
| result.insert(k, v); | result.insert(k, v); | ||||
| } | } | ||||
| } | } | ||||
| result | result | ||||
| } | } | ||||
| } | } | ||||
| /// represent the side that should prevail when merging two | /// represent the side that should prevail when merging two | ||||
| /// TimeStampedPathCopies | /// InternalPathCopies | ||||
| enum MergePick { | enum MergePick { | ||||
| /// The "major" (p1) side prevails | /// The "major" (p1) side prevails | ||||
| Major, | Major, | ||||
| /// The "minor" (p2) side prevails | /// The "minor" (p2) side prevails | ||||
| Minor, | Minor, | ||||
| /// Any side could be used (because they are the same) | /// Any side could be used (because they are the same) | ||||
| Any, | Any, | ||||
| } | } | ||||