"""

revlog.py - storage back-end for mercurial

This provides efficient delta storage with O(1) retrieve and append

and O(changes) merge between branches

Copyright 2005-2007 Matt Mackall <mpm@selenic.com>

This software may be used and distributed according to the terms

of the GNU General Public License, incorporated herein by reference.

"""

from node import bin, hex, nullid, nullrev, short

from i18n import _

import changegroup, errno, ancestor, mdiff, parsers

import struct, util, zlib

_pack = struct.pack

_unpack = struct.unpack

_compress = zlib.compress

_decompress = zlib.decompress

_sha = util.sha1

# revlog flags

REVLOGV0 = 0

REVLOGNG = 1

REVLOGNGINLINEDATA = (1 << 16)

REVLOG_DEFAULT_FLAGS = REVLOGNGINLINEDATA

REVLOG_DEFAULT_FORMAT = REVLOGNG

REVLOG_DEFAULT_VERSION = REVLOG_DEFAULT_FORMAT | REVLOG_DEFAULT_FLAGS

class RevlogError(Exception):

    pass

class LookupError(RevlogError, KeyError):

    def __init__(self, name, index, message):

        self.name = name

        if isinstance(name, str) and len(name) == 20:

            name = short(name)

        RevlogError.__init__(self, _('%s@%s: %s') % (index, name, message))

    def __str__(self):

        return RevlogError.__str__(self)

def getoffset(q):

    return int(q >> 16)

def gettype(q):

    return int(q & 0xFFFF)

def offset_type(offset, type):

    return long(long(offset) << 16 | type)

def hash(text, p1, p2):

    """generate a hash from the given text and its parent hashes

    This hash combines both the current file contents and its history

    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):

    """ generate a possibly-compressed representation of text """

    if not text:

        return ("", text)

    l = len(text)

    bin = None

    if l < 44:

        pass

    elif l > 1000000:

        # zlib makes an internal copy, thus doubling memory usage for

        # large files, so lets do this in pieces

        z = zlib.compressobj()

        p = []

        pos = 0

        while pos < l:

            pos2 = pos + 2**20

            p.append(z.compress(text[pos:pos2]))

            pos = pos2

        p.append(z.flush())

        if sum(map(len, p)) < l:

            bin = "".join(p)

    else:

        bin = _compress(text)

    if bin is None or len(bin) > l:

        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 _decompress(bin)

    if t == 'u':

        return bin[1:]

    raise RevlogError(_("unknown compression type %r") % t)

class lazyparser(object):

    """

    this class avoids the need to parse the entirety of large indices

    """

    # lazyparser is not safe to use on windows if win32 extensions not

    # available. it keeps file handle open, which make it not possible

    # to break hardlinks on local cloned repos.

    def __init__(self, dataf, size):

        self.dataf = dataf

        self.s = struct.calcsize(indexformatng)

        self.datasize = size

        self.l = size/self.s

        self.index = [None] * self.l

        self.map = {nullid: nullrev}

        self.allmap = 0

        self.all = 0

        self.mapfind_count = 0

    def loadmap(self):

        """

        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

        self.dataf.seek(0)

        while cur < end:

            data = self.dataf.read(blocksize)

            off = 0

            for x in xrange(256):

                n = data[off + ngshaoffset:off + ngshaoffset + 20]

                self.map[n] = count

                count += 1

                if count >= self.l:

                    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.

                # limit blocksize so that we don't get too much data.

                blocksize = max(self.datasize - blockstart, 0)

            data = self.dataf.read(blocksize)

        lend = len(data) / self.s

        i = blockstart / self.s

        off = 0

        # lazyindex supports __delitem__

        if lend > len(self.index) - i:

            lend = len(self.index) - i

        for x in xrange(lend):

            if self.index[i + x] == None:

                b = data[off : off + self.s]

                self.index[i + x] = b

                n = b[ngshaoffset:ngshaoffset + 20]

                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:

            self.loadmap()

            if node in self.map:

                return node

            return None

        self.mapfind_count += 1

        last = self.l - 1

        while self.index[last] != None:

            if last == 0:

                self.all = 1

                self.allmap = 1

                return None

            last -= 1

        end = (last + 1) * self.s

        blocksize = self.s * 256

        while end >= 0:

            start = max(end - blocksize, 0)

            self.dataf.seek(start)

            data = self.dataf.read(end - start)

            findend = end - start

            while True:

                # we're searching backwards, so we have to make sure

                # we don't find a changeset where this node is a parent

                off = data.find(node, 0, findend)

                findend = off

                if off >= 0:

                    i = off / self.s

                    off = i * self.s

                    n = data[off + ngshaoffset:off + ngshaoffset + 20]

                    if n == node:

                        self.map[n] = i + start / self.s

                        return node

                else:

                    break

            end -= blocksize

        return None

    def loadindex(self, i=None, end=None):

        if self.all:

            return

        all = False

        if i == None:

            blockstart = 0

            blocksize = (65536 / self.s) * self.s

            end = self.datasize

            all = True

        else:

            if end:

                blockstart = i * self.s

                end = end * self.s

                blocksize = end - blockstart

            else:

                blockstart = (i & ~1023) * self.s

                blocksize = self.s * 1024

                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 __len__(self):

        return len(self.p.index)

    def load(self, pos):

        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

    def load(self, key):

        n = self.p.findnode(key)

        if n == None:

            raise KeyError(key)

    def __contains__(self, key):

        if key in self.p.map:

            return True

        self.p.loadmap()

        return key in self.p.map

    def __iter__(self):

        yield nullid

        for i in xrange(self.p.l):

            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:

            try:

                self.load(key)

                return self.p.map[key]

            except KeyError:

                raise KeyError("node " + hex(key))

    def __setitem__(self, key, val):

        self.p.map[key] = val

    def __delitem__(self, key):

        del self.p.map[key]

indexformatv0 = ">4l20s20s20s"

v0shaoffset = 56

class revlogoldio(object):

    def __init__(self):

        self.size = struct.calcsize(indexformatv0)

    def parseindex(self, fp, inline):

        s = self.size

        index = []

        nodemap =  {nullid: nullrev}

        n = off = 0

        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.get(e[4], nullrev), nodemap.get(e[5], nullrev), e[6])

            index.append(e2)

            nodemap[e[6]] = n

            n += 1

        return index, nodemap, None

    def packentry(self, entry, node, version, rev):

        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

# 4 bytes uncompressed length

# 4 bytes: base rev

# 4 bytes link rev

# 4 bytes parent 1 rev

# 4 bytes parent 2 rev

# 32 bytes: nodeid

indexformatng = ">Qiiiiii20s12x"

ngshaoffset = 32

versionformat = ">I"

class revlogio(object):

    def __init__(self):

        self.size = struct.calcsize(indexformatng)

    def parseindex(self, fp, inline):

        try:

            size = util.fstat(fp).st_size

        except AttributeError:

            size = 0

        if util.openhardlinks() and not inline and size > 1000000: