comparison mercurial/ancestor.py @ 40300:72b94f946e90

rust: rustlazyancestors.__contains__

This changeset provides a Rust implementation of
the iteration performed by lazyancestor.__contains__

It has the advantage over the Python iteration to use
the 'seen' set encapsuled into the dedicated iterator (self._containsiter),
rather than storing emitted items in another set (self._containsseen),
and hence should reduce the memory footprint.

Also, there's no need to convert intermediate emitted revisions back into
Python integers.

At this point, it would be tempting to implement the whole lazyancestor object
in Rust, but that would lead to more C wrapping code (two objects) for
little expected benefits.

40299:3570adf20d91

            # Set to None to indicate fast-path can be used next time, and to
            # free up memory.
            self._containsiter = None
            return False

class rustlazyancestors(lazyancestors):

    def __init__(self, index, revs, stoprev=0, inclusive=False):
        self._index = index
        self._stoprev = stoprev
        self._inclusive = inclusive

        # it's done by rustlazyancestors constructor.
        # we need to convert to a list, because our ruslazyancestors
        # constructor (from C code) doesn't understand anything else yet
        self._initrevs = initrevs = list(revs)

        self._containsseen = set()
        self._containsiter = parsers.rustlazyancestors(
            index, initrevs, stoprev, inclusive)

    def __iter__(self):
        return parsers.rustlazyancestors(self._index,
                                         self._initrevs,
                                         self._stoprev,
                                         self._inclusive)

40300:72b94f946e90

            # Set to None to indicate fast-path can be used next time, and to
            # free up memory.
            self._containsiter = None
            return False

class rustlazyancestors(object):

    def __init__(self, index, revs, stoprev=0, inclusive=False):
        self._index = index
        self._stoprev = stoprev
        self._inclusive = inclusive

        # it's done by rustlazyancestors constructor.
        # we need to convert to a list, because our ruslazyancestors
        # constructor (from C code) doesn't understand anything else yet
        self._initrevs = initrevs = list(revs)

        self._containsiter = parsers.rustlazyancestors(
            index, initrevs, stoprev, inclusive)

    def __nonzero__(self):
        """False if the set is empty, True otherwise.

        It's better to duplicate this essentially trivial method than
        to subclass lazyancestors
        """
        try:
            next(iter(self))
            return True
        except StopIteration:
            return False

    def __iter__(self):
        return parsers.rustlazyancestors(self._index,
                                         self._initrevs,
                                         self._stoprev,
                                         self._inclusive)

    def __contains__(self, target):
        return target in self._containsiter