comparison rust/hg-core/src/revlog/index.rs @ 51228:61a6ef876efd

rust-index: simplification in find_gca_candidates()

`parent_seen` can be made a mutable ref, making this part more obvious,
not needing to be commented so much.

The micro-optimization of avoiding the union if `parent_seen` and
`current_seen` agree is pushed down in the `union()` method of the
fast, `u64` based bit set implementation (in case it matters).

51227:e553cd209215

            }
            for parent in self.parents(current_rev)? {
                if parent == NULL_REVISION {
                    continue;
                }
                let parent_seen = &seen[parent.0 as usize];
                if poison {
                    // this block is logically equivalent to poisoning parent
                    // and counting it as non interesting if it
                    // has been seen before (hence counted then as interesting)
                    if !parent_seen.is_empty() && !parent_seen.is_poisoned() {
                        interesting -= 1;
                    }
                    seen[parent.0 as usize].poison();
                } else {
                    // Without the `interesting` accounting, this block would
                    // be logically equivalent to: parent_seen |= current_seen
                    // The parent counts as interesting if it was not already
                    // known to be an ancestor (would already have counted)
                    if parent_seen.is_empty() {
                        seen[parent.0 as usize] = current_seen.clone();
                        interesting += 1;
                    } else if *parent_seen != current_seen {
                        seen[parent.0 as usize].union(&current_seen);
                    }
                }
            }

            current_rev = Revision(current_rev.0 - 1);
        }

    fn discard(&mut self, n: usize) {
        (*self) &= u64::MAX - (1u64 << n);
    }

    fn union(&mut self, other: &Self) {
        (*self) |= *other;
    }

    fn is_full_range(&self, n: usize) -> bool {
        *self + 1 == (1u64 << n)
    }

51228:61a6ef876efd

            }
            for parent in self.parents(current_rev)? {
                if parent == NULL_REVISION {
                    continue;
                }
                let parent_seen = &mut seen[parent.0 as usize];
                if poison {
                    // this block is logically equivalent to poisoning parent
                    // and counting it as non interesting if it
                    // has been seen before (hence counted then as interesting)
                    if !parent_seen.is_empty() && !parent_seen.is_poisoned() {
                        interesting -= 1;
                    }
                    parent_seen.poison();
                } else {
                    if parent_seen.is_empty() {
                        interesting += 1;
                    }
                    parent_seen.union(&current_seen);
                }
            }

            current_rev = Revision(current_rev.0 - 1);
        }

    fn discard(&mut self, n: usize) {
        (*self) &= u64::MAX - (1u64 << n);
    }

    fn union(&mut self, other: &Self) {
        if *self != *other {
            (*self) |= *other;
        }
    }

    fn is_full_range(&self, n: usize) -> bool {
        *self + 1 == (1u64 << n)
    }