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

comparison mercurial/localrepo.py @ 16745:27b2e1823e83

branchcache: backout 0311a6abd38a

author	Matt Mackall <mpm@selenic.com>
date	Thu, 17 May 2012 15:34:59 -0500
parents	e825a89de5d7
children	b3435385f99f

comparison

equal deleted inserted replaced

-:1c9f58a6c8f1
+:27b2e1823e83
 for l in lines:
 if not l:
 continue
 node, label = l.split(" ", 1)
 label = encoding.tolocal(label.strip())
-if not node in self:
-raise ValueError('invalidating branch cache because node '+
-'%s does not exist' % node)
 partial.setdefault(label, []).append(bin(node))
 except KeyboardInterrupt:
 raise
 except Exception, inst:
 if self.ui.debugflag:
 f.close()
 except (IOError, OSError):
 pass
 def _updatebranchcache(self, partial, ctxgen):
-"""Given a branchhead cache, partial, that may have extra nodes or be
-missing heads, and a generator of nodes that are at least a superset of
-heads missing, this function updates partial to be correct.
-"""
 # collect new branch entries
 newbranches = {}
 for c in ctxgen:
 newbranches.setdefault(c.branch(), []).append(c.node())
 # if older branchheads are reachable from new ones, they aren't
 # really branchheads. Note checking parents is insufficient:
 # 1 (branch a) -> 2 (branch b) -> 3 (branch a)
 for branch, newnodes in newbranches.iteritems():
 bheads = partial.setdefault(branch, [])
 bheads.extend(newnodes)
-# Remove duplicates - nodes that are in newnodes and are already in
+if len(bheads) <= 1:
-# bheads.  This can happen if you strip a node and its parent was
+continue
-# already a head (because they're on different branches).
+bheads = sorted(bheads, key=lambda x: self[x].rev())
-bheads = set(bheads)
+# starting from tip means fewer passes over reachable
+while newnodes:
-# Remove candidate heads that no longer are in the repo (e.g., as
+latest = newnodes.pop()
-# the result of a strip that just happened).
+if latest not in bheads:
-# avoid using 'bhead in self' here because that dives down into
+continue
-# branchcache code somewhat recrusively.
+minbhnode = self[bheads[0]].node()
-bheads = [bhead for bhead in bheads \
+reachable = self.changelog.reachable(latest, minbhnode)
-if self.changelog.hasnode(bhead)]
+reachable.remove(latest)
-if len(bheads) > 1:
+if reachable:
-bheads = sorted(bheads, key=lambda x: self[x].rev())
+bheads = [b for b in bheads if b not in reachable]
-# starting from tip means fewer passes over reachable
-while newnodes:
-latest = newnodes.pop()
-if latest not in bheads:
-continue
-minbhnode = self[bheads[0]].node()
-reachable = self.changelog.reachable(latest, minbhnode)
-reachable.remove(latest)
-if reachable:
-bheads = [b for b in bheads if b not in reachable]
 partial[branch] = bheads
-# There may be branches that cease to exist when the last commit in the
-# branch was stripped.  This code filters them out.  Note that the
-# branch that ceased to exist may not be in newbranches because
-# newbranches is the set of candidate heads, which when you strip the
-# last commit in a branch will be the parent branch.
-for branch in partial.keys():
-nodes = [head for head in partial[branch] \
-if self.changelog.hasnode(head)]
-if len(nodes) < 1:
-del partial[branch]
 def lookup(self, key):
 return self[key].node()
 def lookupbranch(self, key, remote=None):
 ui.status(_('working directory now based on '
 'revisions %d and %d\n') % parents)
 else:
 ui.status(_('working directory now based on '
 'revision %d\n') % parents)
-# TODO: if we know which new heads may result from this rollback, pass
-# them to destroy(), which will prevent the branchhead cache from being
-# invalidated.
 self.destroyed()
 return 0
 def invalidatecaches(self):
 def delcache(name):
 finally:
 if tr:
 tr.release()
 lock.release()
-def destroyed(self, newheadrevs=None):
+def destroyed(self):
 '''Inform the repository that nodes have been destroyed.
 Intended for use by strip and rollback, so there's a common
-place for anything that has to be done after destroying history.
+place for anything that has to be done after destroying history.'''
+# XXX it might be nice if we could take the list of destroyed
-If you know the branchheadcache was uptodate before nodes were removed
+# nodes, but I don't see an easy way for rollback() to do that
-and you also know the set of candidate set of new heads that may have
-resulted from the destruction, you can set newheadrevs.  This will
-enable the code to update the branchheads cache, rather than having
-future code decide it's invalid and regenrating it.
-'''
-if newheadrevs:
-tiprev = len(self) - 1
-ctxgen = (self[rev] for rev in newheadrevs)
-self._updatebranchcache(self._branchcache, ctxgen)
-self._writebranchcache(self._branchcache, self.changelog.tip(),
-tiprev)
-else:
-# No info to update the cache.  If nodes were destroyed, the cache
-# is stale and this will be caught the next time it is read.
-pass
 # Ensure the persistent tag cache is updated.  Doing it now
 # means that the tag cache only has to worry about destroyed
 # heads immediately after a strip/rollback.  That in turn
 # guarantees that "cachetip == currenttip" (comparing both rev

Mercurial > public > mercurial-scm > hg

comparison mercurial/localrepo.py @ 16745:27b2e1823e83