mercurial/revset.py

22861:546fa6576815

        `condition` is a callable which takes a revision number and returns a
        boolean.

        This is part of the mandatory API for smartset."""
        kwargs = {}
        if self.isascending():
            kwargs['ascending'] = True
        elif self.isdescending():
            kwargs['ascending'] = False
        return filteredset(self, condition, **kwargs)

class baseset(abstractsmartset):
    """Basic data structure that represents a revset and contains the basic
    operation that it should be able to perform.

class filteredset(abstractsmartset):
    """Duck type for baseset class which iterates lazily over the revisions in
    the subset and contains a function which tests for membership in the
    revset
    """
    def __init__(self, subset, condition=lambda x: True, ascending=None):
        """
        condition: a function that decide whether a revision in the subset
                   belongs to the revset or not.
        """
        self._subset = subset
        self._condition = condition
        self._cache = {}
        if ascending is not None:
            ascending = bool(ascending)
        self._ascending = ascending

    def __contains__(self, x):
        c = self._cache
        if x not in c:
            v = c[x] = x in self._subset and self._condition(x)

        # Basic implementation to be changed in future patches.
        l = baseset([r for r in self])
        return l[x]

    def sort(self, reverse=False):
        if self._ascending is None:
            if not util.safehasattr(self._subset, 'sort'):
                self._subset = baseset(self._subset)
            self._subset.sort(reverse=reverse)
            self._ascending = not reverse
        elif bool(reverse) == self._ascending:
            self.reverse()

    def reverse(self):
        self._subset.reverse()
        if self._ascending is not None:
            self._ascending = not self._ascending

    def set(self):
        return set([r for r in self])

    def isascending(self):
        return self._ascending is not None and self._ascending

    def isdescending(self):
        return self._ascending is not None and not self._ascending

    def first(self):
        for x in self:
            return x
        return None

    def last(self):
        it = None
        if self._ascending is not None:
            if self._ascending:
                it = self.fastdesc
            else:
                it = self.fastasc
        if it is None:
            # slowly consume everything. This needs improvement
            it = lambda: reversed(list(self))
        for x in it():
            return x

22862:9e5576f822cc

        `condition` is a callable which takes a revision number and returns a
        boolean.

        This is part of the mandatory API for smartset."""
        return filteredset(self, condition)

class baseset(abstractsmartset):
    """Basic data structure that represents a revset and contains the basic
    operation that it should be able to perform.

class filteredset(abstractsmartset):
    """Duck type for baseset class which iterates lazily over the revisions in
    the subset and contains a function which tests for membership in the
    revset
    """
    def __init__(self, subset, condition=lambda x: True):
        """
        condition: a function that decide whether a revision in the subset
                   belongs to the revset or not.
        """
        self._subset = subset
        self._condition = condition
        self._cache = {}

    def __contains__(self, x):
        c = self._cache
        if x not in c:
            v = c[x] = x in self._subset and self._condition(x)

        # Basic implementation to be changed in future patches.
        l = baseset([r for r in self])
        return l[x]

    def sort(self, reverse=False):
        self._subset.sort(reverse=reverse)

    def reverse(self):
        self._subset.reverse()

    def set(self):
        return set([r for r in self])

    def isascending(self):
        return self._subset.isascending()

    def isdescending(self):
        return self._subset.isdescending()

    def first(self):
        for x in self:
            return x
        return None

    def last(self):
        it = None
        if self._subset.isascending:
            it = self.fastdesc
        elif self._subset.isdescending:
            it = self.fastdesc
        if it is None:
            # slowly consume everything. This needs improvement
            it = lambda: reversed(list(self))
        for x in it():
            return x