comparison mercurial/revlog.py @ 43574:02802fa87b74

revlog: deprecate direct `nodemap` access

Now that all in-core user have been updated to the new API, we can deprecated
direct access to nodemap.

Differential Revision: https://phab.mercurial-scm.org/D7362

43573:d3df05bab081

indexformatv0_pack = indexformatv0.pack
indexformatv0_unpack = indexformatv0.unpack


class revlogoldindex(list):
    @util.propertycache
    def nodemap(self):
        nodemap = revlogutils.NodeMap({nullid: nullrev})
        for r in range(0, len(self)):
            n = self[r][7]
            nodemap[n] = r
        return nodemap

    def has_node(self, node):
        """return True if the node exist in the index"""
        return node in self.nodemap

    def rev(self, node):
        """return a revision for a node

        If the node is unknown, raise a RevlogError"""
        return self.nodemap[node]

    def get_rev(self, node):
        """return a revision for a node

        If the node is unknown, return None"""
        return self.nodemap.get(node)

    def append(self, tup):
        self.nodemap[tup[7]] = len(self)
        super(revlogoldindex, self).append(tup)

    def __delitem__(self, i):
        if not isinstance(i, slice) or not i.stop == -1 or i.step is not None:
            raise ValueError(b"deleting slices only supports a:-1 with step 1")
        for r in pycompat.xrange(i.start, len(self)):
            del self.nodemap[self[r][7]]
        super(revlogoldindex, self).__delitem__(i)

    def clearcaches(self):
        self.__dict__.pop('nodemap', None)

    def __getitem__(self, i):
        if i == -1:
            return (0, 0, 0, -1, -1, -1, -1, nullid)
        return list.__getitem__(self, i)

        except (ValueError, IndexError):
            raise error.RevlogError(
                _(b"index %s is corrupted") % self.indexfile
            )
        self.index, self._chunkcache = d
        self.nodemap = self.index.nodemap
        if not self._chunkcache:
            self._chunkclear()
        # revnum -> (chain-length, sum-delta-length)
        self._chaininfocache = {}
        # revlog header -> revlog compressor

    def revs(self, start=0, stop=None):
        """iterate over all rev in this revlog (from start to stop)"""
        return storageutil.iterrevs(len(self), start=start, stop=stop)

    @util.propertycache
    def nodemap(self):
        return self.index.nodemap

    @property
    def _nodecache(self):
        msg = "revlog._nodecache is deprecated, use revlog.index.nodemap"

43574:02802fa87b74

indexformatv0_pack = indexformatv0.pack
indexformatv0_unpack = indexformatv0.unpack


class revlogoldindex(list):
    @property
    def nodemap(self):
        msg = "index.nodemap is deprecated, " "use index.[has_node|rev|get_rev]"
        util.nouideprecwarn(msg, b'5.3', stacklevel=2)
        return self._nodemap

    @util.propertycache
    def _nodemap(self):
        nodemap = revlogutils.NodeMap({nullid: nullrev})
        for r in range(0, len(self)):
            n = self[r][7]
            nodemap[n] = r
        return nodemap

    def has_node(self, node):
        """return True if the node exist in the index"""
        return node in self._nodemap

    def rev(self, node):
        """return a revision for a node

        If the node is unknown, raise a RevlogError"""
        return self._nodemap[node]

    def get_rev(self, node):
        """return a revision for a node

        If the node is unknown, return None"""
        return self._nodemap.get(node)

    def append(self, tup):
        self._nodemap[tup[7]] = len(self)
        super(revlogoldindex, self).append(tup)

    def __delitem__(self, i):
        if not isinstance(i, slice) or not i.stop == -1 or i.step is not None:
            raise ValueError(b"deleting slices only supports a:-1 with step 1")
        for r in pycompat.xrange(i.start, len(self)):
            del self._nodemap[self[r][7]]
        super(revlogoldindex, self).__delitem__(i)

    def clearcaches(self):
        self.__dict__.pop('_nodemap', None)

    def __getitem__(self, i):
        if i == -1:
            return (0, 0, 0, -1, -1, -1, -1, nullid)
        return list.__getitem__(self, i)

        except (ValueError, IndexError):
            raise error.RevlogError(
                _(b"index %s is corrupted") % self.indexfile
            )
        self.index, self._chunkcache = d
        if not self._chunkcache:
            self._chunkclear()
        # revnum -> (chain-length, sum-delta-length)
        self._chaininfocache = {}
        # revlog header -> revlog compressor

    def revs(self, start=0, stop=None):
        """iterate over all rev in this revlog (from start to stop)"""
        return storageutil.iterrevs(len(self), start=start, stop=stop)

    @property
    def nodemap(self):
        msg = (
            "revlog.nodemap is deprecated, "
            "use revlog.index.[has_node|rev|get_rev]"
        )
        util.nouideprecwarn(msg, b'5.3', stacklevel=2)
        return self.index.nodemap

    @property
    def _nodecache(self):
        msg = "revlog._nodecache is deprecated, use revlog.index.nodemap"