comparison mercurial/localrepo.py @ 18125:ad194a8ab5c1

branchmap: add the tipnode (cache key) on the branchcache object

Gathering data and cache key paves the way to a lot of simplification.

18124:79db6d40bced

        if create:
            self._writerequirements()


        self._branchcache = None
        self._branchcachetip = None
        self.filterpats = {}
        self._datafilters = {}
        self._transref = self._lockref = self._wlockref = None

        # A cache for various files under .hg/ that tracks file changes,

        if '_tagscache' in vars(self):
            # can't use delattr on proxy
            del self.__dict__['_tagscache']

        self.unfiltered()._branchcache = None # in UTF-8
        self.unfiltered()._branchcachetip = None
        self.invalidatevolatilesets()

    def invalidatevolatilesets(self):
        self.filteredrevcache.clear()
        obsolete.clearobscaches(self)

        if newheadnodes:
            tiprev = len(self) - 1
            ctxgen = (self[node] for node in newheadnodes
                      if self.changelog.hasnode(node))
            branchmap.update(self, self._branchcache, ctxgen)
            branchmap.write(self, self._branchcache, self.changelog.tip(),
                            tiprev)

        # 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

                    rbheads.extend(bheads)

                if rbheads:
                    rtiprev = max((int(self.changelog.rev(node))
                            for node in rbheads))
                    self._branchcache = branchmap.branchcache(rbranchmap)
                    rtipnode = self._branchcachetip = self[rtiprev].node()
                    branchmap.write(self, self._branchcache, rtipnode, rtiprev)
            self.invalidate()
            return len(self.heads()) + 1
        finally:
            lock.release()

18125:ad194a8ab5c1

        if create:
            self._writerequirements()


        self._branchcache = None
        self.filterpats = {}
        self._datafilters = {}
        self._transref = self._lockref = self._wlockref = None

        # A cache for various files under .hg/ that tracks file changes,

        if '_tagscache' in vars(self):
            # can't use delattr on proxy
            del self.__dict__['_tagscache']

        self.unfiltered()._branchcache = None # in UTF-8
        self.invalidatevolatilesets()

    def invalidatevolatilesets(self):
        self.filteredrevcache.clear()
        obsolete.clearobscaches(self)

        if newheadnodes:
            tiprev = len(self) - 1
            ctxgen = (self[node] for node in newheadnodes
                      if self.changelog.hasnode(node))
            branchmap.update(self, self._branchcache, ctxgen)
            self._branchcache.tipnode = self.changelog.tip()
            branchmap.write(self, self._branchcache, self._branchcache.tipnode,
                            tiprev)

        # 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

                    rbheads.extend(bheads)

                if rbheads:
                    rtiprev = max((int(self.changelog.rev(node))
                            for node in rbheads))
                    cache = branchmap.branchcache(rbranchmap,
                                                  self[rtiprev].node())
                    self._branchcache = cache
                    branchmap.write(self, cache, cache.tipnode, rtiprev)
            self.invalidate()
            return len(self.heads()) + 1
        finally:
            lock.release()