| Alphare | |
| pulkit |
| hg-reviewers |
We are going to add more cases, to it is time to stop using early returns and to
move everything in a single if/elif/else block for clarity.
| 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 (119 lines) |
| /// 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>( | ||||
| minor: TimeStampedPathCopies, | minor: TimeStampedPathCopies, | ||||
| major: TimeStampedPathCopies, | major: TimeStampedPathCopies, | ||||
| changes: &ChangedFiles, | changes: &ChangedFiles, | ||||
| oracle: &mut AncestorOracle<A>, | oracle: &mut AncestorOracle<A>, | ||||
| ) -> TimeStampedPathCopies { | ) -> TimeStampedPathCopies { | ||||
| if minor.is_empty() { | if minor.is_empty() { | ||||
| return major; | major | ||||
| } else if major.is_empty() { | } else if major.is_empty() { | ||||
| return minor; | minor | ||||
| } | } else { | ||||
| let mut override_minor = Vec::new(); | let mut override_minor = Vec::new(); | ||||
| let mut override_major = Vec::new(); | let mut override_major = Vec::new(); | ||||
| let mut to_major = |k: &HgPathBuf, v: &TimeStampedPathCopy| { | let mut to_major = |k: &HgPathBuf, v: &TimeStampedPathCopy| { | ||||
| override_major.push((k.clone(), v.clone())) | override_major.push((k.clone(), v.clone())) | ||||
| }; | }; | ||||
| let mut to_minor = |k: &HgPathBuf, v: &TimeStampedPathCopy| { | let mut to_minor = |k: &HgPathBuf, v: &TimeStampedPathCopy| { | ||||
| override_minor.push((k.clone(), v.clone())) | override_minor.push((k.clone(), v.clone())) | ||||
| }; | }; | ||||
| // The diff function leverage detection of the identical subpart if minor | // The diff function leverage detection of the identical subpart if | ||||
| // and major has some common ancestors. This make it very fast is most | // minor and major has some common ancestors. This make it very | ||||
| // case. | // fast is most case. | ||||
| // | // | ||||
| // In case where the two map are vastly different in size, the current | // In case where the two map are vastly different in size, the current | ||||
| // approach is still slowish because the iteration will iterate over | // approach is still slowish because the iteration will iterate over | ||||
| // all the "exclusive" content of the larger on. This situation can be | // all the "exclusive" content of the larger on. This situation can be | ||||
| // frequent when the subgraph of revision we are processing has a lot | // frequent when the subgraph of revision we are processing has a lot | ||||
| // of roots. Each roots adding they own fully new map to the mix (and | // of roots. Each roots adding they own fully new map to the mix (and | ||||
| // likely a small map, if the path from the root to the "main path" is | // likely a small map, if the path from the root to the "main path" is | ||||
| // small. | // small. | ||||
| // | // | ||||
| // We could do better by detecting such situation and processing them | // We could do better by detecting such situation and processing them | ||||
| // differently. | // differently. | ||||
| for d in minor.diff(&major) { | for d in minor.diff(&major) { | ||||
| match d { | match d { | ||||
| DiffItem::Add(k, v) => to_minor(k, v), | DiffItem::Add(k, v) => to_minor(k, v), | ||||
| DiffItem::Remove(k, v) => to_major(k, v), | DiffItem::Remove(k, v) => to_major(k, v), | ||||
| DiffItem::Update { old, new } => { | DiffItem::Update { old, new } => { | ||||
| let (dest, src_major) = new; | let (dest, src_major) = new; | ||||
| let (_, src_minor) = old; | let (_, src_minor) = old; | ||||
| match compare_value( | match compare_value( | ||||
| changes, oracle, dest, src_minor, src_major, | changes, oracle, dest, src_minor, src_major, | ||||
| ) { | ) { | ||||
| MergePick::Major => to_minor(dest, src_major), | MergePick::Major => to_minor(dest, src_major), | ||||
| MergePick::Minor => to_major(dest, src_minor), | MergePick::Minor => to_major(dest, src_minor), | ||||
| // If the two entry are identical, no need to do | // If the two entry are identical, no need to do | ||||
| // anything (but diff should not have yield them) | // anything (but diff should not have yield them) | ||||
| MergePick::Any => unreachable!(), | MergePick::Any => unreachable!(), | ||||
| } | } | ||||
| } | } | ||||
| }; | }; | ||||
| } | } | ||||
| let updates; | let updates; | ||||
| let mut result; | let mut result; | ||||
| if override_major.is_empty() { | if override_major.is_empty() { | ||||
| result = major | result = major | ||||
| } else if override_minor.is_empty() { | } else if override_minor.is_empty() { | ||||
| result = minor | result = minor | ||||
| } else { | } else { | ||||
| if override_minor.len() < override_major.len() { | if override_minor.len() < override_major.len() { | ||||
| updates = override_minor; | updates = override_minor; | ||||
| result = minor; | result = minor; | ||||
| } else { | } else { | ||||
| updates = override_major; | updates = override_major; | ||||
| result = major; | result = major; | ||||
| } | } | ||||
| for (k, v) in updates { | for (k, v) in updates { | ||||
| 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 | /// TimeStampedPathCopies | ||||
| 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, | ||||