comparison mercurial/ancestor.py @ 39481:b6a0e06b0f7d

lazyancestors: extract __iter__ to free function

The next patch will keep a reference to the returned iterator in a
field, which would otherwise result in a reference cycle.

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

39480:89630d0b3e23

                    thisvisit.add(p)

        missing.reverse()
        return missing

class lazyancestors(object):
    def __init__(self, pfunc, revs, stoprev=0, inclusive=False):
        """Create a new object generating ancestors for the given revs. Does
        not generate revs lower than stoprev.

        revision number order. That order is also topological: a child is
        always emitted before its parent.

        If inclusive is True, the source revisions are also yielded. The
        reverse revision number order is still enforced."""
        seen = {nullrev}
        revs = self._initrevs

        parentrevs = self._parentrevs
        stoprev = self._stoprev
        schedule = heapq.heappush
        nextitem = heapq.heappop
        see = seen.add

        if self._inclusive:
            visit = [-r for r in revs]
            seen.update(revs)
            heapq.heapify(visit)
        else:
            visit = []
            heapq.heapify(visit)
            for r in revs:
                for parent in parentrevs(r):
                    if parent not in seen:
                        schedule(visit, -parent)
                        see(parent)

        while visit:
            current = -nextitem(visit)
            if current >= stoprev:
                yield current
                for parent in parentrevs(current):
                    if parent not in seen:
                        schedule(visit, -parent)
                        see(parent)

    def __contains__(self, target):
        """Test whether target is an ancestor of self._initrevs."""
        # Trying to do both __iter__ and __contains__ using the same visit
        # heap and seen set is complex enough that it slows down both. Keep

39481:b6a0e06b0f7d

                    thisvisit.add(p)

        missing.reverse()
        return missing

# Extracted from lazyancestors.__iter__ to avoid a reference cycle
def _lazyancestorsiter(parentrevs, initrevs, stoprev, inclusive):
    seen = {nullrev}
    revs = initrevs

    schedule = heapq.heappush
    nextitem = heapq.heappop
    see = seen.add

    if inclusive:
        visit = [-r for r in revs]
        seen.update(revs)
        heapq.heapify(visit)
    else:
        visit = []
        heapq.heapify(visit)
        for r in revs:
            for parent in parentrevs(r):
                if parent not in seen:
                    schedule(visit, -parent)
                    see(parent)

    while visit:
        current = -nextitem(visit)
        if current >= stoprev:
            yield current
            for parent in parentrevs(current):
                if parent not in seen:
                    schedule(visit, -parent)
                    see(parent)

class lazyancestors(object):
    def __init__(self, pfunc, revs, stoprev=0, inclusive=False):
        """Create a new object generating ancestors for the given revs. Does
        not generate revs lower than stoprev.

        revision number order. That order is also topological: a child is
        always emitted before its parent.

        If inclusive is True, the source revisions are also yielded. The
        reverse revision number order is still enforced."""
        for rev in _lazyancestorsiter(self._parentrevs, self._initrevs,
                                      self._stoprev, self._inclusive):
            yield rev

    def __contains__(self, target):
        """Test whether target is an ancestor of self._initrevs."""
        # Trying to do both __iter__ and __contains__ using the same visit
        # heap and seen set is complex enough that it slows down both. Keep