comparison rust/hg-core/src/copy_tracing.rs @ 46611:b6f65d90e8af

copies-rust: add methods to build and update CopySource

Having explicit method with clear semantic help to clarify the code and prepare
an update to the underlying documentation without too much disruption.

Differential Revision: https://phab.mercurial-scm.org/D9643

46610:3c5a8b13206a

pub type PathCopies = HashMap<HgPathBuf, HgPathBuf>;

type PathToken = usize;

#[derive(Clone, Debug, PartialEq, Copy)]
struct CopySource {
    /// revision at which the copy information was added
    rev: Revision,
    /// the copy source, (Set to None in case of deletion of the associated
    /// key)
    path: Option<PathToken>,
}

/// maps CopyDestination to Copy Source (+ a "timestamp" for the operation)
type InternalPathCopies = OrdMap<PathToken, CopySource>;

                // record this information as we will need it to take
                // the right decision when merging conflicting copy
                // information. See merge_copies_dict for details.
                match copies.entry(dest) {
                    Entry::Vacant(slot) => {
                        let ttpc = CopySource {
                            rev: current_rev,
                            path: entry,
                        };
                        slot.insert(ttpc);
                    }
                    Entry::Occupied(mut slot) => {
                        let mut ttpc = slot.get_mut();
                        oracle.record_overwrite(ttpc.rev, current_rev);
                        ttpc.rev = current_rev;
                        ttpc.path = entry;
                    }
                }
            }
            Action::Removed(deleted_path) => {
                // We must drop copy information for removed file.

                // propagate this information when merging two
                // InternalPathCopies object.
                let deleted = path_map.tokenize(deleted_path);
                copies.entry(deleted).and_modify(|old| {
                    oracle.record_overwrite(old.rev, current_rev);
                    old.rev = current_rev;
                    old.path = None;
                });
            }
        }
    }
    copies

                    let (pick, overwrite) =
                        cmp_value(oracle, &dest, &src_minor, src_major);
                    if overwrite {
                        oracle.record_overwrite(src_minor.rev, current_merge);
                        oracle.record_overwrite(src_major.rev, current_merge);
                        let path = match pick {
                            MergePick::Major => src_major.path,
                            MergePick::Minor => src_minor.path,
                            MergePick::Any => src_major.path,
                        };
                        let src = CopySource {
                            rev: current_merge,
                            path,
                        };
                        major.insert(dest, src);
                    } else {
                        match pick {
                            MergePick::Any | MergePick::Major => None,

                    let (pick, overwrite) =
                        cmp_value(oracle, &dest, src_minor, &src_major);
                    if overwrite {
                        oracle.record_overwrite(src_minor.rev, current_merge);
                        oracle.record_overwrite(src_major.rev, current_merge);
                        let path = match pick {
                            MergePick::Major => src_minor.path,
                            MergePick::Minor => src_major.path,
                            MergePick::Any => src_major.path,
                        };
                        let src = CopySource {
                            rev: current_merge,
                            path,
                        };
                        minor.insert(dest, src);
                    } else {
                        match pick {
                            MergePick::Any | MergePick::Minor => None,

                    let (pick, overwrite) =
                        cmp_value(oracle, dest, src_minor, src_major);
                    if overwrite {
                        oracle.record_overwrite(src_minor.rev, current_merge);
                        oracle.record_overwrite(src_major.rev, current_merge);
                        let path = match pick {
                            MergePick::Major => src_major.path,
                            MergePick::Minor => src_minor.path,
                            // If the two entry are identical, no need to do
                            // anything (but diff should not have yield them)
                            MergePick::Any => src_major.path,
                        };
                        let src = CopySource {
                            rev: current_merge,
                            path,
                        };
                        to_minor(dest, &src);
                        to_major(dest, &src);
                    } else {
                        match pick {

46611:b6f65d90e8af

pub type PathCopies = HashMap<HgPathBuf, HgPathBuf>;

type PathToken = usize;

#[derive(Clone, Debug, PartialEq)]
struct CopySource {
    /// revision at which the copy information was added
    rev: Revision,
    /// the copy source, (Set to None in case of deletion of the associated
    /// key)
    path: Option<PathToken>,
}

impl CopySource {
    /// create a new CopySource
    ///
    /// Use this when no previous copy source existed.
    fn new(rev: Revision, path: Option<PathToken>) -> Self {
        Self { rev, path }
    }

    /// create a new CopySource from merging two others
    ///
    /// Use this when merging two InternalPathCopies requires active merging of
    /// some entries.
    fn new_from_merge(rev: Revision, winner: &Self, loser: &Self) -> Self {
        Self {
            rev,
            path: winner.path,
        }
    }

    /// Update the value of a pre-existing CopySource
    ///
    /// Use this when recording copy information from  parent → child edges
    fn overwrite(&mut self, rev: Revision, path: Option<PathToken>) {
        self.rev = rev;
        self.path = path;
    }

    /// Mark pre-existing copy information as "dropped" by a file deletion
    ///
    /// Use this when recording copy information from  parent → child edges
    fn mark_delete(&mut self, rev: Revision) {
        self.rev = rev;
        self.path = None;
    }
}

/// maps CopyDestination to Copy Source (+ a "timestamp" for the operation)
type InternalPathCopies = OrdMap<PathToken, CopySource>;

                // record this information as we will need it to take
                // the right decision when merging conflicting copy
                // information. See merge_copies_dict for details.
                match copies.entry(dest) {
                    Entry::Vacant(slot) => {
                        let ttpc = CopySource::new(current_rev, entry);
                        slot.insert(ttpc);
                    }
                    Entry::Occupied(mut slot) => {
                        let ttpc = slot.get_mut();
                        oracle.record_overwrite(ttpc.rev, current_rev);
                        ttpc.overwrite(current_rev, entry);
                    }
                }
            }
            Action::Removed(deleted_path) => {
                // We must drop copy information for removed file.

                // propagate this information when merging two
                // InternalPathCopies object.
                let deleted = path_map.tokenize(deleted_path);
                copies.entry(deleted).and_modify(|old| {
                    oracle.record_overwrite(old.rev, current_rev);
                    old.mark_delete(current_rev);
                });
            }
        }
    }
    copies

                    let (pick, overwrite) =
                        cmp_value(oracle, &dest, &src_minor, src_major);
                    if overwrite {
                        oracle.record_overwrite(src_minor.rev, current_merge);
                        oracle.record_overwrite(src_major.rev, current_merge);
                        let src = match pick {
                            MergePick::Major => CopySource::new_from_merge(
                                current_merge,
                                src_major,
                                &src_minor,
                            ),
                            MergePick::Minor => CopySource::new_from_merge(
                                current_merge,
                                &src_minor,
                                src_major,
                            ),
                            MergePick::Any => CopySource::new_from_merge(
                                current_merge,
                                src_major,
                                &src_minor,
                            ),
                        };
                        major.insert(dest, src);
                    } else {
                        match pick {
                            MergePick::Any | MergePick::Major => None,

                    let (pick, overwrite) =
                        cmp_value(oracle, &dest, src_minor, &src_major);
                    if overwrite {
                        oracle.record_overwrite(src_minor.rev, current_merge);
                        oracle.record_overwrite(src_major.rev, current_merge);
                        let src = match pick {
                            MergePick::Major => CopySource::new_from_merge(
                                current_merge,
                                &src_major,
                                src_minor,
                            ),
                            MergePick::Minor => CopySource::new_from_merge(
                                current_merge,
                                src_minor,
                                &src_major,
                            ),
                            MergePick::Any => CopySource::new_from_merge(
                                current_merge,
                                &src_major,
                                src_minor,
                            ),
                        };
                        minor.insert(dest, src);
                    } else {
                        match pick {
                            MergePick::Any | MergePick::Minor => None,

                    let (pick, overwrite) =
                        cmp_value(oracle, dest, src_minor, src_major);
                    if overwrite {
                        oracle.record_overwrite(src_minor.rev, current_merge);
                        oracle.record_overwrite(src_major.rev, current_merge);
                        let src = match pick {
                            MergePick::Major => CopySource::new_from_merge(
                                current_merge,
                                src_major,
                                src_minor,
                            ),
                            MergePick::Minor => CopySource::new_from_merge(
                                current_merge,
                                src_minor,
                                src_major,
                            ),
                            MergePick::Any => CopySource::new_from_merge(
                                current_merge,
                                src_major,
                                src_minor,
                            ),
                        };
                        to_minor(dest, &src);
                        to_major(dest, &src);
                    } else {
                        match pick {