mercurial-scm/hg: comparison mercurial/revset.py

equal deleted inserted replaced

-:88e5483bfb20
+:169aa5e74b52
 if not rev in descendants and not rev in include]
 else:
 exclude = getset(repo, spanset(repo), args[1])
 results = set(ancestormod.missingancestors(include, exclude, cl.parentrevs))
-return lazyset(subset, results.__contains__)
+return filteredset(subset, results.__contains__)
 def bisect(repo, subset, x):
 """``bisect(string)``
 Changesets marked in the specified bisect status:
 # in the correct order.
 args.ascending()
 result = (orderedlazyset(s, subset.__contains__, ascending=True) +
 orderedlazyset(args, subset.__contains__, ascending=True))
-# Wrap result in a lazyset since it's an _addset, which doesn't implement
+# Wrap result in a filteredset since it's an _addset, which doesn't
-# all the necessary functions to be consumed by callers.
+# implement all the necessary functions to be consumed by callers.
 return orderedlazyset(result, lambda r: True, ascending=True)
 def descendants(repo, subset, x):
 """``descendants(set)``
 Changesets which are descendants of changesets in set.
 def __sub__(self, other):
 """Returns a new object with the substraction of the two collections.
 This is part of the mandatory API for smartset."""
 # If we are operating on 2 baseset, do the computation now since all
-# data is available. The alternative is to involve a lazyset, which
+# data is available. The alternative is to involve a filteredset, which
 # may be slow.
 if isinstance(other, baseset):
 other = other.set()
 return baseset([x for x in self if x not in other])
 `condition` is a callable which takes a revision number and returns a
 boolean.
 This is part of the mandatory API for smartset."""
-return lazyset(self, condition)
+return filteredset(self, condition)
 class _orderedsetmixin(object):
 """Mixin class with utility methods for smartsets
 This should be extended by smartsets which have the isascending(),
 """return the largest element in the set"""
 if self.isascending():
 return self._last()
 return self._first()
-class lazyset(abstractsmartset):
+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):
 if it is None:
 return None
 return lambda: self._iterfilter(it())
 def __and__(self, x):
-return lazyset(self, x.__contains__)
+return filteredset(self, x.__contains__)
 def __sub__(self, x):
-return lazyset(self, lambda r: r not in x)
+return filteredset(self, lambda r: r not in x)
 def __add__(self, x):
 return _addset(self, x)
 def __nonzero__(self):
 def isdescending(self):
 return self._ascending is not None and not self._ascending
 def filter(self, l):
-return lazyset(self, l)
+return filteredset(self, l)
-class orderedlazyset(_orderedsetmixin, lazyset):
+class orderedlazyset(_orderedsetmixin, filteredset):
-"""Subclass of lazyset which subset can be ordered either ascending or
+"""Subclass of filteredset which subset can be ordered either ascending or
 descendingly
 """
 def __init__(self, subset, condition, ascending=True):
 super(orderedlazyset, self).__init__(subset, condition)
 self._ascending = ascending
 return self._genlist
 def filter(self, condition):
 if self._ascending is not None:
 return orderedlazyset(self, condition, ascending=self._ascending)
-return lazyset(self, condition)
+return filteredset(self, condition)
 def ascending(self):
 if self._ascending is None:
 self.sort()
 self._ascending = True
 def __and__(self, other):
 filterfunc = other.__contains__
 if self._ascending is not None:
 return orderedlazyset(self, filterfunc, ascending=self._ascending)
-return lazyset(self, filterfunc)
+return filteredset(self, filterfunc)
 def __sub__(self, other):
 filterfunc = lambda r: r not in other
 if self._ascending is not None:
 return orderedlazyset(self, filterfunc, ascending=self._ascending)
-return lazyset(self, filterfunc)
+return filteredset(self, filterfunc)
 def __add__(self, other):
 """When both collections are ascending or descending, preserve the order
 """
 kwargs = {}

changeset 22726	169aa5e74b52
parent 22725	88e5483bfb20
child 22727	0f3e240a1c35