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

comparison mercurial/revset.py @ 20365:bc770ee6a351

revset: implemented set caching for revset evaluation Added set caching to the baseset class. It lazily builds the set whenever it's needed and keeps a reference which is returned when the set is requested instead of being built again.

author	Lucas Moscovicz <lmoscovicz@fb.com>
date	Wed, 22 Jan 2014 10:46:02 -0800
parents	a6cf48b2880d
children	5ec6321f49a9

comparison

equal deleted inserted replaced

-:a6cf48b2880d
+:bc770ee6a351
 if m < n:
 r = range(m, n + 1)
 else:
 r = range(m, n - 1, -1)
-s = set(subset)
+s = subset.set()
 return baseset([x for x in r if x in s])
 def dagrange(repo, subset, x, y):
 r = baseset(repo)
 xs = _revsbetween(repo, getset(repo, r, x), getset(repo, r, y))
-s = set(subset)
+s = subset.set()
 return baseset([r for r in xs if r in s])
 def andset(repo, subset, x, y):
 return getset(repo, getset(repo, subset, x), y)
 def orset(repo, subset, x, y):
 xl = getset(repo, subset, x)
-s = set(xl)
+s = xl.set()
-yl = getset(repo, [r for r in subset if r not in s], y)
+yl = getset(repo, baseset([r for r in subset if r not in s]), y)
 return baseset(xl + yl)
 def notset(repo, subset, x):
-s = set(getset(repo, subset, x))
+s = getset(repo, subset, x).set()
 return baseset([r for r in subset if r not in s])
 def listset(repo, subset, a, b):
 raise error.ParseError(_("can't use a list in this context"))
 def _ancestors(repo, subset, x, followfirst=False):
 args = getset(repo, baseset(repo), x)
 if not args:
 return baseset([])
 s = set(_revancestors(repo, args, followfirst)) | set(args)
-return baseset([r for r in subset if r in s])
+ss = subset.set()
+return baseset([r for r in ss if r in s])
 def ancestors(repo, subset, x):
 """``ancestors(set)``
 Changesets that are ancestors of a changeset in set.
 """
 cl = repo.changelog
 for r in getset(repo, cl, x):
 for i in range(n):
 r = cl.parentrevs(r)[0]
 ps.add(r)
-return baseset([r for r in subset if r in ps])
+s = subset.set()
+return baseset([r for r in s if r in ps])
 def author(repo, subset, x):
 """``author(string)``
 Alias for ``user(string)``.
 """
 - ``current``            : the cset currently being bisected
 """
 # i18n: "bisect" is a keyword
 status = getstring(x, _("bisect requires a string")).lower()
 state = set(hbisect.get(repo, status))
-return baseset([r for r in subset if r in state])
+s = subset.set()
+return baseset([r for r in s if r in state])
 # Backward-compatibility
 # - no help entry so that we do not advertise it any more
 def bisected(repo, subset, x):
 return bisect(repo, subset, x)
 raise util.Abort(_("no bookmarks exist that match '%s'")
 % pattern)
 bmrevs = set()
 for bmrev in matchrevs:
 bmrevs.add(repo[bmrev].rev())
-return baseset([r for r in subset if r in bmrevs])
+s = subset.set()
+return baseset([r for r in s if r in bmrevs])
 bms = set([repo[r].rev()
 for r in repo._bookmarks.values()])
-return baseset([r for r in subset if r in bms])
+s = subset.set()
+return baseset([r for r in s if r in bms])
 def branch(repo, subset, x):
 """``branch(string or set)``
 All changesets belonging to the given branch or the branches of the given
 changesets.
 s = getset(repo, baseset(repo), x)
 b = set()
 for r in s:
 b.add(repo[r].branch())
-s = set(s)
+s = s.set()
 return baseset([r for r in subset if r in s or repo[r].branch() in b])
 def bumped(repo, subset, x):
 """``bumped()``
 Mutable changesets marked as successors of public changesets.
 def children(repo, subset, x):
 """``children(set)``
 Child changesets of changesets in set.
 """
-s = set(getset(repo, baseset(repo), x))
+s = getset(repo, baseset(repo), x).set()
 cs = _children(repo, subset, s)
 return baseset([r for r in subset if r in cs])
 def closed(repo, subset, x):
 """``closed()``
 def _descendants(repo, subset, x, followfirst=False):
 args = getset(repo, baseset(repo), x)
 if not args:
 return baseset([])
 s = set(_revdescendants(repo, args, followfirst)) | set(args)
-return baseset([r for r in subset if r in s])
+ss = subset.set()
+return baseset([r for r in ss if r in s])
 def descendants(repo, subset, x):
 """``descendants(set)``
 Changesets which are descendants of changesets in set.
 """
 Changesets that were created by a graft, transplant or rebase operation,
 with the given revisions specified as the source.  Omitting the optional set
 is the same as passing all().
 """
 if x is not None:
-args = set(getset(repo, baseset(repo), x))
+args = getset(repo, baseset(repo), x).set()
 else:
-args = set(getall(repo, baseset(repo), x))
+args = getall(repo, baseset(repo), x).set()
 dests = set()
 # subset contains all of the possible destinations that can be returned, so
 # iterate over them and see if their source(s) were provided in the args.
 if m(f):
 fl = repo.file(f)
 for fr in fl:
 s.add(fl.linkrev(fr))
-return baseset([r for r in subset if r in s])
+ss = subset.set()
+return baseset([r for r in ss if r in s])
 def first(repo, subset, x):
 """``first(set, [n])``
 An alias for limit().
 """
 else:
 return baseset([])
 else:
 s = set(_revancestors(repo, [c.rev()], followfirst)) | set([c.rev()])
-return baseset([r for r in subset if r in s])
+ss = subset.set()
+return baseset([r for r in ss if r in s])
 def follow(repo, subset, x):
 """``follow([file])``
 An alias for ``::.`` (ancestors of the working copy's first parent).
 If a filename is specified, the history of the given file is followed,
 # i18n: "head" is a keyword
 getargs(x, 0, 0, _("head takes no arguments"))
 hs = set()
 for b, ls in repo.branchmap().iteritems():
 hs.update(repo[h].rev() for h in ls)
-return baseset([r for r in subset if r in hs])
+s = subset.set()
+return baseset([r for r in s if r in hs])
 def heads(repo, subset, x):
 """``heads(set)``
 Members of set with no children in set.
 """
-s = getset(repo, subset, x)
+s = getset(repo, subset, x).set()
-ps = set(parents(repo, subset, x))
+ps = parents(repo, subset, x).set()
 return baseset([r for r in s if r not in ps])
 def hidden(repo, subset, x):
 """``hidden()``
 Hidden changesets.
 # i18n: "limit" is a keyword
 lim = int(getstring(l[1], _("limit requires a number")))
 except (TypeError, ValueError):
 # i18n: "limit" is a keyword
 raise error.ParseError(_("limit expects a number"))
-ss = set(subset)
+ss = subset.set()
 os = getset(repo, baseset(repo), l[0])[:lim]
 return baseset([r for r in os if r in ss])
 def last(repo, subset, x):
 """``last(set, [n])``
 # i18n: "last" is a keyword
 lim = int(getstring(l[1], _("last requires a number")))
 except (TypeError, ValueError):
 # i18n: "last" is a keyword
 raise error.ParseError(_("last expects a number"))
-ss = set(subset)
+ss = subset.set()
 os = getset(repo, baseset(repo), l[0])[-lim:]
 return baseset([r for r in os if r in ss])
 def maxrev(repo, subset, x):
 """``max(set)``
 same as passing all().  If a changeset created by these operations is itself
 specified as a source for one of these operations, only the source changeset
 for the first operation is selected.
 """
 if x is not None:
-args = set(getset(repo, baseset(repo), x))
+args = getset(repo, baseset(repo), x).set()
 else:
-args = set(getall(repo, baseset(repo), x))
+args = getall(repo, baseset(repo), x).set()
 def _firstsrc(rev):
 src = _getrevsource(repo, rev)
 if src is None:
 return None
 if prev is None:
 return src
 src = prev
 o = set([_firstsrc(r) for r in args])
-return baseset([r for r in subset if r in o])
+s = subset.set()
+return baseset([r for r in s if r in o])
 def outgoing(repo, subset, x):
 """``outgoing([path])``
 Changesets not found in the specified destination repository, or the
 default push location.
 repo.ui.pushbuffer()
 outgoing = discovery.findcommonoutgoing(repo, other, onlyheads=revs)
 repo.ui.popbuffer()
 cl = repo.changelog
 o = set([cl.rev(r) for r in outgoing.missing])
-return baseset([r for r in subset if r in o])
+s = subset.set()
+return baseset([r for r in s if r in o])
 def p1(repo, subset, x):
 """``p1([set])``
 First parent of changesets in set, or the working directory.
 """
 ps = set()
 cl = repo.changelog
 for r in getset(repo, baseset(repo), x):
 ps.add(cl.parentrevs(r)[0])
-return baseset([r for r in subset if r in ps])
+s = subset.set()
+return baseset([r for r in s if r in ps])
 def p2(repo, subset, x):
 """``p2([set])``
 Second parent of changesets in set, or the working directory.
 """
 ps = set()
 cl = repo.changelog
 for r in getset(repo, baseset(repo), x):
 ps.add(cl.parentrevs(r)[1])
-return baseset([r for r in subset if r in ps])
+s = subset.set()
+return baseset([r for r in s if r in ps])
 def parents(repo, subset, x):
 """``parents([set])``
 The set of all parents for all changesets in set, or the working directory.
 """
 ps = set()
 cl = repo.changelog
 for r in getset(repo, baseset(repo), x):
 ps.update(cl.parentrevs(r))
-return baseset([r for r in subset if r in ps])
+s = subset.set()
+return baseset([r for r in s if r in ps])
 def parentspec(repo, subset, x, n):
 """``set^0``
 The set.
 ``set^1`` (or ``set^``), ``set^2``
 ps.add(cl.parentrevs(r)[0])
 elif n == 2:
 parents = cl.parentrevs(r)
 if len(parents) > 1:
 ps.add(parents[1])
-return baseset([r for r in subset if r in ps])
+s = subset.set()
+return baseset([r for r in s if r in ps])
 def present(repo, subset, x):
 """``present(set)``
 An empty set, if any revision in set isn't found; otherwise,
 all revisions in set.
 def reverse(repo, subset, x):
 """``reverse(set)``
 Reverse order of set.
 """
 l = getset(repo, subset, x)
-if not isinstance(l, list):
-l = baseset(l)
 l.reverse()
 return l
 def roots(repo, subset, x):
 """``roots(set)``
 Changesets in set with no parent changeset in set.
 """
-s = set(getset(repo, baseset(repo.changelog), x))
+s = getset(repo, baseset(repo.changelog), x).set()
 subset = baseset([r for r in subset if r in s])
 cs = _children(repo, subset, s)
 return baseset([r for r in subset if r not in cs])
 def secret(repo, subset, x):
 # for internal use
 def _list(repo, subset, x):
 s = getstring(x, "internal error")
 if not s:
 return baseset([])
-if not isinstance(subset, set):
-subset = set(subset)
 ls = [repo[r].rev() for r in s.split('\0')]
-return baseset([r for r in ls if r in subset])
+s = subset.set()
+return baseset([r for r in ls if r in s])
 symbols = {
 "adds": adds,
 "all": getall,
 "ancestor": ancestor,
 if tree[0] == 'func':
 funcs.add(tree[1][1])
 return funcs
 class baseset(list):
-pass
+def __init__(self, data):
+super(baseset, self).__init__(data)
+self._set = None
+def set(self):
+if not self._set:
+self._set = set(self)
+return self._set
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = symbols.values()

Mercurial > public > mercurial-scm > hg

comparison mercurial/revset.py @ 20365:bc770ee6a351