comparison mercurial/revlog.py @ 5007:3addf4531643

revlog: localize some fastpath functions

5006:c2febf5420e9

from node import *
from i18n import _
import binascii, changegroup, errno, ancestor, mdiff, os
import sha, struct, util, zlib

# revlog flags
REVLOGV0 = 0
REVLOGNG = 1
REVLOGNGINLINEDATA = (1 << 16)

    in a manner that makes it easy to distinguish nodes with the same
    content in the revision graph.
    """
    l = [p1, p2]
    l.sort()
    s = sha.new(l[0])
    s.update(l[1])
    s.update(text)
    return s.digest()

def compress(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)

        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)

class lazyparser(object):

        if pos < 0:
            pos += len(self.p.index)
        self.p.loadindex(pos)
        return self.p.index[pos]
    def __getitem__(self, pos):
        return struct.unpack(indexformatng,
                             self.p.index[pos] or self.load(pos))
    def __setitem__(self, pos, item):
        self.p.index[pos] = struct.pack(indexformatng, *item)
    def __delitem__(self, pos):
        del self.p.index[pos]
    def insert(self, pos, e):
        self.p.index.insert(pos, struct.pack(indexformatng, *e))
    def append(self, e):
        self.p.index.append(struct.pack(indexformatng, *e))

class lazymap(object):
    """a lazy version of the node map"""
    def __init__(self, parser):
        self.p = parser

            ret = self.p.index[i]
            if not ret:
                self.p.loadindex(i)
                ret = self.p.index[i]
            if isinstance(ret, str):
                ret = struct.unpack(indexformatng, ret)
            yield ret[7]
    def __getitem__(self, key):
        try:
            return self.p.map[key]
        except KeyError:

        data = fp.read()
        l = len(data)
        while off + s <= l:
            cur = data[off:off + s]
            off += s
            e = struct.unpack(indexformatv0, cur)
            # transform to revlogv1 format
            e2 = (offset_type(e[0], 0), e[1], -1, e[2], e[3],
                  nodemap[e[4]], nodemap[e[5]], e[6])
            index.append(e2)
            nodemap[e[6]] = n

        return index, nodemap, None

    def packentry(self, entry, node, version):
        e2 = (getoffset(entry[0]), entry[1], entry[3], entry[4],
              node(entry[5]), node(entry[6]), entry[7])
        return struct.pack(indexformatv0, *e2)

# index ng:
# 6 bytes offset
# 2 bytes flags
# 4 bytes compressed length

        nodemap =  {nullid: nullrev}
        n = off = 0
        # if we're not using lazymap, always read the whole index
        data = fp.read()
        l = len(data) - s
        unpack = struct.unpack
        append = index.append
        if inline:
            cache = (0, data)
            while off <= l:
                e = unpack(indexformatng, data[off:off + s])
                nodemap[e[7]] = n
                append(e)
                n += 1
                if e[1] < 0:
                    break
                off += e[1] + s
        else:
            while off <= l:
                e = unpack(indexformatng, data[off:off + s])
                nodemap[e[7]] = n
                append(e)
                n += 1
                off += s

        index[0] = e

        return index, nodemap, cache

    def packentry(self, entry, node, version):
        p = struct.pack(indexformatng, *entry)
        if not entry[3] and not getoffset(entry[0]) and entry[5] == nullrev:
            p = struct.pack(versionformat, version) + p[4:]
        return p

class revlog(object):
    """
    the underlying revision storage object

5007:3addf4531643

from node import *
from i18n import _
import binascii, changegroup, errno, ancestor, mdiff, os
import sha, struct, util, zlib

_pack = struct.pack
_unpack = struct.unpack
_compress = zlib.compress
_decompress = zlib.decompress
_sha = sha.new

# revlog flags
REVLOGV0 = 0
REVLOGNG = 1
REVLOGNGINLINEDATA = (1 << 16)

    in a manner that makes it easy to distinguish nodes with the same
    content in the revision graph.
    """
    l = [p1, p2]
    l.sort()
    s = _sha(l[0])
    s.update(l[1])
    s.update(text)
    return s.digest()

def compress(text):

        return ("", text)
    if len(text) < 44:
        if text[0] == '\0':
            return ("", text)
        return ('u', text)
    bin = _compress(text)
    if len(bin) > len(text):
        if text[0] == '\0':
            return ("", text)
        return ('u', text)
    return ("", bin)

        return bin
    t = bin[0]
    if t == '\0':
        return bin
    if t == 'x':
        return _decompress(bin)
    if t == 'u':
        return bin[1:]
    raise RevlogError(_("unknown compression type %r") % t)

class lazyparser(object):

        if pos < 0:
            pos += len(self.p.index)
        self.p.loadindex(pos)
        return self.p.index[pos]
    def __getitem__(self, pos):
        return _unpack(indexformatng, self.p.index[pos] or self.load(pos))
    def __setitem__(self, pos, item):
        self.p.index[pos] = _pack(indexformatng, *item)
    def __delitem__(self, pos):
        del self.p.index[pos]
    def insert(self, pos, e):
        self.p.index.insert(pos, _pack(indexformatng, *e))
    def append(self, e):
        self.p.index.append(_pack(indexformatng, *e))

class lazymap(object):
    """a lazy version of the node map"""
    def __init__(self, parser):
        self.p = parser

            ret = self.p.index[i]
            if not ret:
                self.p.loadindex(i)
                ret = self.p.index[i]
            if isinstance(ret, str):
                ret = _unpack(indexformatng, ret)
            yield ret[7]
    def __getitem__(self, key):
        try:
            return self.p.map[key]
        except KeyError:

        data = fp.read()
        l = len(data)
        while off + s <= l:
            cur = data[off:off + s]
            off += s
            e = _unpack(indexformatv0, cur)
            # transform to revlogv1 format
            e2 = (offset_type(e[0], 0), e[1], -1, e[2], e[3],
                  nodemap[e[4]], nodemap[e[5]], e[6])
            index.append(e2)
            nodemap[e[6]] = n

        return index, nodemap, None

    def packentry(self, entry, node, version):
        e2 = (getoffset(entry[0]), entry[1], entry[3], entry[4],
              node(entry[5]), node(entry[6]), entry[7])
        return _pack(indexformatv0, *e2)

# index ng:
# 6 bytes offset
# 2 bytes flags
# 4 bytes compressed length

        nodemap =  {nullid: nullrev}
        n = off = 0
        # if we're not using lazymap, always read the whole index
        data = fp.read()
        l = len(data) - s
        append = index.append
        if inline:
            cache = (0, data)
            while off <= l:
                e = _unpack(indexformatng, data[off:off + s])
                nodemap[e[7]] = n
                append(e)
                n += 1
                if e[1] < 0:
                    break
                off += e[1] + s
        else:
            while off <= l:
                e = _unpack(indexformatng, data[off:off + s])
                nodemap[e[7]] = n
                append(e)
                n += 1
                off += s

        index[0] = e

        return index, nodemap, cache

    def packentry(self, entry, node, version):
        p = _pack(indexformatng, *entry)
        if not entry[3] and not getoffset(entry[0]) and entry[5] == nullrev:
            p = _pack(versionformat, version) + p[4:]
        return p

class revlog(object):
    """
    the underlying revision storage object