mercurial/revlog.py

4979:06abdaf78788

    s.update(text)
    return s.digest()

def compress(text):
    """ generate a possibly-compressed representation of text """
    if not text: return ("", text)
    if len(text) < 44:
        if text[0] == '\0': return ("", text)
        return ('u', text)
    bin = zlib.compress(text)
    if len(bin) > len(text):
        if text[0] == '\0': return ("", text)
        return ('u', text)
    return ("", bin)

def decompress(bin):
    """ decompress the given input """
    if not bin: return bin
    t = bin[0]
    if t == '\0': return bin
    if t == 'x': return zlib.decompress(bin)
    if t == 'u': return bin[1:]
    raise RevlogError(_("unknown compression type %r") % t)

indexformatv0 = ">4l20s20s20s"
v0shaoffset = 56
# index ng:

        during a commit, we need to make sure the rev being added is
        not a duplicate.  This requires loading the entire index,
        which is fairly slow.  loadmap can load up just the node map,
        which takes much less time.
        """
        if self.allmap: return
        end = self.datasize
        self.allmap = 1
        cur = 0
        count = 0
        blocksize = self.s * 256

                    break
                off += self.s
            cur += blocksize

    def loadblock(self, blockstart, blocksize, data=None):
        if self.all: return
        if data is None:
            self.dataf.seek(blockstart)
            if blockstart + blocksize > self.datasize:
                # the revlog may have grown since we've started running,
                # but we don't have space in self.index for more entries.

                self.map[n] = i + x
            off += self.s

    def findnode(self, node):
        """search backwards through the index file for a specific node"""
        if self.allmap: return None

        # hg log will cause many many searches for the manifest
        # nodes.  After we get called a few times, just load the whole
        # thing.
        if self.mapfind_count > 8:

                    break
            end -= blocksize
        return None

    def loadindex(self, i=None, end=None):
        if self.all: return
        all = False
        if i == None:
            blockstart = 0
            blocksize = (512 / self.s) * self.s
            end = self.datasize

                blocksize = self.s * 64
                end = blockstart + blocksize
        while blockstart < end:
            self.loadblock(blockstart, blocksize)
            blockstart += blocksize
        if all: self.all = True

class lazyindex(object):
    """a lazy version of the index array"""
    def __init__(self, parser):
        self.p = parser

    def __setitem__(self, key, val):
        self.p.map[key] = val
    def __delitem__(self, key):
        del self.p.map[key]

class RevlogError(Exception): pass
class LookupError(RevlogError): pass

def getoffset(q):
    if q & 0xFFFF:
        raise RevlogError(_('incompatible revision flag %x') % q)
    return int(q >> 16)

        """loads the map from the lazy parser"""
        if isinstance(self.nodemap, lazymap):
            self.nodemap.p.loadmap()
            self.nodemap = self.nodemap.p.map

    def _inline(self): return self.version & REVLOGNGINLINEDATA

    def tip(self): return self.node(len(self.index) - 2)
    def count(self): return len(self.index) - 1
    def node(self, rev):
        return self.index[rev][7]
    def rev(self, node):
        try:
            return self.nodemap[node]
        except KeyError:
            raise LookupError(_('%s: no node %s') % (self.indexfile, hex(node)))
    def linkrev(self, node):
        return self.index[self.rev(node)][4]
    def parents(self, node):
        d = self.index[self.rev(node)][5:7]
        return (self.node(d[0]), self.node(d[1]))
    def parentrevs(self, rev):
        return self.index[rev][5:7]
    def start(self, rev):
        return getoffset(self.index[rev][0])
    def end(self, rev): return self.start(rev) + self.length(rev)

    def size(self, rev):
        """return the length of the uncompressed text for a given revision"""
        l = self.index[rev][2]
        if l >= 0:

        l = len(text)
        for x in xrange(base + 1, rev + 1):
            l = mdiff.patchedsize(l, self.chunk(x))
        return l
        """

    def length(self, rev):
        return self.index[rev][1]
    def base(self, rev):
        return self.index[rev][3]

    def reachable(self, node, stop=None):
        """return a hash of all nodes ancestral to a given node, including
         the node itself, stopping when stop is matched"""
        reachable = {}

            except LookupError:
                pass # may be partial hex id
        try:
            # str(rev)
            rev = int(id)
            if str(rev) != id: raise ValueError
            if rev < 0: rev = self.count() + rev
            if rev < 0 or rev >= self.count(): raise ValueError
            return self.node(rev)
        except (ValueError, OverflowError):
            pass
        if len(id) == 40:
            try:

    def lookup(self, id):
        """locate a node based on:
            - revision number or str(revision number)
            - nodeid or subset of hex nodeid
        """

        n = self._match(id)
        if n is not None:
            return n
        n = self._partialmatch(id)
        if n:

            offset = start - cache_start
        else:
            loadcache(df)
            offset = 0

        #def checkchunk():
        #    df = self.opener(self.datafile)
        #    df.seek(start)
        #    return df.read(length)
        #assert s == checkchunk()
        return decompress(self._io.chunkcache[1][offset:offset + length])

    def delta(self, node):
        """return or calculate a delta between a node and its predecessor"""
        r = self.rev(node)

            return self.diff(self.revision(self.node(rev1)),
                             self.revision(self.node(rev2)))

    def revision(self, node):
        """return an uncompressed revision of a given"""
        if node == nullid: return ""
        if self.cache and self.cache[0] == node: return self.cache[2]

        # look up what we need to read
        text = None
        rev = self.rev(node)
        base = self.base(rev)

            dfh = None
        ifh = self.opener(self.indexfile, "a+")
        return self._addrevision(text, transaction, link, p1, p2, d, ifh, dfh)

    def _addrevision(self, text, transaction, link, p1, p2, d, ifh, dfh):
        if text is None: text = ""
        if p1 is None: p1 = self.tip()
        if p2 is None: p2 = nullid

        node = hash(text, p1, p2)

        if node in self.nodemap:
            return node

4980:fc44c8df9d99

    s.update(text)
    return s.digest()

def compress(text):
    """ generate a possibly-compressed representation of text """
    if not text:
        return ("", text)
    if len(text) < 44:
        if text[0] == '\0':
            return ("", text)
        return ('u', text)
    bin = zlib.compress(text)
    if len(bin) > len(text):
        if text[0] == '\0':
            return ("", text)
        return ('u', text)
    return ("", bin)

def decompress(bin):
    """ decompress the given input """
    if not bin:
        return bin
    t = bin[0]
    if t == '\0':
        return bin
    if t == 'x':
        return zlib.decompress(bin)
    if t == 'u':
        return bin[1:]
    raise RevlogError(_("unknown compression type %r") % t)

indexformatv0 = ">4l20s20s20s"
v0shaoffset = 56
# index ng:

        during a commit, we need to make sure the rev being added is
        not a duplicate.  This requires loading the entire index,
        which is fairly slow.  loadmap can load up just the node map,
        which takes much less time.
        """
        if self.allmap:
            return
        end = self.datasize
        self.allmap = 1
        cur = 0
        count = 0
        blocksize = self.s * 256

                    break
                off += self.s
            cur += blocksize

    def loadblock(self, blockstart, blocksize, data=None):
        if self.all:
            return
        if data is None:
            self.dataf.seek(blockstart)
            if blockstart + blocksize > self.datasize:
                # the revlog may have grown since we've started running,
                # but we don't have space in self.index for more entries.

                self.map[n] = i + x
            off += self.s

    def findnode(self, node):
        """search backwards through the index file for a specific node"""
        if self.allmap:
            return None

        # hg log will cause many many searches for the manifest
        # nodes.  After we get called a few times, just load the whole
        # thing.
        if self.mapfind_count > 8:

                    break
            end -= blocksize
        return None

    def loadindex(self, i=None, end=None):
        if self.all:
            return
        all = False
        if i == None:
            blockstart = 0
            blocksize = (512 / self.s) * self.s
            end = self.datasize

                blocksize = self.s * 64
                end = blockstart + blocksize
        while blockstart < end:
            self.loadblock(blockstart, blocksize)
            blockstart += blocksize
        if all:
            self.all = True

class lazyindex(object):
    """a lazy version of the index array"""
    def __init__(self, parser):
        self.p = parser

    def __setitem__(self, key, val):
        self.p.map[key] = val
    def __delitem__(self, key):
        del self.p.map[key]

class RevlogError(Exception):
    pass
class LookupError(RevlogError):
    pass

def getoffset(q):
    if q & 0xFFFF:
        raise RevlogError(_('incompatible revision flag %x') % q)
    return int(q >> 16)

        """loads the map from the lazy parser"""
        if isinstance(self.nodemap, lazymap):
            self.nodemap.p.loadmap()
            self.nodemap = self.nodemap.p.map

    def _inline(self):
        return self.version & REVLOGNGINLINEDATA
    def tip(self):
        return self.node(len(self.index) - 2)
    def count(self):
        return len(self.index) - 1

    def rev(self, node):
        try:
            return self.nodemap[node]
        except KeyError:
            raise LookupError(_('%s: no node %s') % (self.indexfile, hex(node)))
    def node(self, rev):
        return self.index[rev][7]
    def linkrev(self, node):
        return self.index[self.rev(node)][4]
    def parents(self, node):
        d = self.index[self.rev(node)][5:7]
        return (self.node(d[0]), self.node(d[1]))
    def parentrevs(self, rev):
        return self.index[rev][5:7]
    def start(self, rev):
        return getoffset(self.index[rev][0])
    def end(self, rev):
        return self.start(rev) + self.length(rev)
    def length(self, rev):
        return self.index[rev][1]
    def base(self, rev):
        return self.index[rev][3]

    def size(self, rev):
        """return the length of the uncompressed text for a given revision"""
        l = self.index[rev][2]
        if l >= 0:

        l = len(text)
        for x in xrange(base + 1, rev + 1):
            l = mdiff.patchedsize(l, self.chunk(x))
        return l
        """

    def reachable(self, node, stop=None):
        """return a hash of all nodes ancestral to a given node, including
         the node itself, stopping when stop is matched"""
        reachable = {}

            except LookupError:
                pass # may be partial hex id
        try:
            # str(rev)
            rev = int(id)
            if str(rev) != id:
                raise ValueError
            if rev < 0:
                rev = self.count() + rev
            if rev < 0 or rev >= self.count():
                raise ValueError
            return self.node(rev)
        except (ValueError, OverflowError):
            pass
        if len(id) == 40:
            try:

    def lookup(self, id):
        """locate a node based on:
            - revision number or str(revision number)
            - nodeid or subset of hex nodeid
        """
        n = self._match(id)
        if n is not None:
            return n
        n = self._partialmatch(id)
        if n:

            offset = start - cache_start
        else:
            loadcache(df)
            offset = 0

        return decompress(self._io.chunkcache[1][offset:offset + length])

    def delta(self, node):
        """return or calculate a delta between a node and its predecessor"""
        r = self.rev(node)

            return self.diff(self.revision(self.node(rev1)),
                             self.revision(self.node(rev2)))

    def revision(self, node):
        """return an uncompressed revision of a given"""
        if node == nullid:
            return ""
        if self.cache and self.cache[0] == node:
            return self.cache[2]

        # look up what we need to read
        text = None
        rev = self.rev(node)
        base = self.base(rev)

            dfh = None
        ifh = self.opener(self.indexfile, "a+")
        return self._addrevision(text, transaction, link, p1, p2, d, ifh, dfh)

    def _addrevision(self, text, transaction, link, p1, p2, d, ifh, dfh):
        if text is None:
            text = ""
        if p1 is None:
            p1 = self.tip()
        if p2 is None:
            p2 = nullid

        node = hash(text, p1, p2)

        if node in self.nodemap:
            return node