mercurial/revlog.py

35635:0b52c0ecbc23

            if prev not in tested:
                # other approach failed try against prev to hopefully save us a
                # fulltext.
                yield (prev,)

    def _addrevision(self, node, rawtext, transaction, link, p1, p2, flags,
                     cachedelta, ifh, dfh, alwayscache=False):
        """internal function to add revisions to the log

        see addrevision for argument descriptions.

            fh = ifh
        else:
            fh = dfh

        btext = [rawtext]
        def buildtext():
            if btext[0] is not None:
                return btext[0]
            baserev = cachedelta[0]
            delta = cachedelta[1]
            # special case deltas which replace entire base; no need to decode
            # base revision. this neatly avoids censored bases, which throw when
            # they're decoded.
            hlen = struct.calcsize(">lll")
            if delta[:hlen] == mdiff.replacediffheader(self.rawsize(baserev),
                                                       len(delta) - hlen):
                btext[0] = delta[hlen:]
            else:
                basetext = self.revision(baserev, _df=fh, raw=True)
                btext[0] = mdiff.patch(basetext, delta)

            try:
                res = self._processflags(btext[0], flags, 'read', raw=True)
                btext[0], validatehash = res
                if validatehash:
                    self.checkhash(btext[0], node, p1=p1, p2=p2)
                if flags & REVIDX_ISCENSORED:
                    raise RevlogError(_('node %s is not censored') % node)
            except CensoredNodeError:
                # must pass the censored index flag to add censored revisions
                if not flags & REVIDX_ISCENSORED:
                    raise
            return btext[0]

        def builddelta(rev):
            # can we use the cached delta?
            if cachedelta and cachedelta[0] == rev:
                delta = cachedelta[1]
            else:
                t = buildtext()
                if self.iscensored(rev):
                    # deltas based on a censored revision must replace the
                    # full content in one patch, so delta works everywhere
                    header = mdiff.replacediffheader(self.rawsize(rev), len(t))
                    delta = header + t

                break

        if delta is not None:
            dist, l, data, base, chainbase, chainlen, compresseddeltalen = delta
        else:
            rawtext = buildtext()
            data = self.compress(rawtext)
            l = len(data[1]) + len(data[0])
            base = chainbase = curr

        e = (offset_type(offset, flags), l, textlen,

        entry = self._io.packentry(e, self.node, self.version, curr)
        self._writeentry(transaction, ifh, dfh, entry, data, link, offset)

        if alwayscache and rawtext is None:
            rawtext = buildtext()

        if type(rawtext) == str: # only accept immutable objects
            self._cache = (node, curr, rawtext)
        self._chainbasecache[curr] = chainbase
        return node

35636:8108bb51309d

            if prev not in tested:
                # other approach failed try against prev to hopefully save us a
                # fulltext.
                yield (prev,)

    def _buildtext(self, node, p1, p2, btext, cachedelta, fh, flags):
        """Builds a fulltext version of a revision

        node:       expected hash of the revision
        p1, p2:     parent revs of the revision
        btext:      built text cache consisting of a one-element list
        cachedelta: (baserev, uncompressed_delta) or None
        fh:         file handle to either the .i or the .d revlog file,
                    depending on whether it is inlined or not
        flags:      flags associated to the revision storage

        One of btext[0] or cachedelta must be set.
        """
        if btext[0] is not None:
            return btext[0]
        baserev = cachedelta[0]
        delta = cachedelta[1]
        # special case deltas which replace entire base; no need to decode
        # base revision. this neatly avoids censored bases, which throw when
        # they're decoded.
        hlen = struct.calcsize(">lll")
        if delta[:hlen] == mdiff.replacediffheader(self.rawsize(baserev),
                                                   len(delta) - hlen):
            btext[0] = delta[hlen:]
        else:
            basetext = self.revision(baserev, _df=fh, raw=True)
            btext[0] = mdiff.patch(basetext, delta)

        try:
            res = self._processflags(btext[0], flags, 'read', raw=True)
            btext[0], validatehash = res
            if validatehash:
                self.checkhash(btext[0], node, p1=p1, p2=p2)
            if flags & REVIDX_ISCENSORED:
                raise RevlogError(_('node %s is not censored') % node)
        except CensoredNodeError:
            # must pass the censored index flag to add censored revisions
            if not flags & REVIDX_ISCENSORED:
                raise
        return btext[0]

    def _addrevision(self, node, rawtext, transaction, link, p1, p2, flags,
                     cachedelta, ifh, dfh, alwayscache=False):
        """internal function to add revisions to the log

        see addrevision for argument descriptions.

            fh = ifh
        else:
            fh = dfh

        btext = [rawtext]

        def builddelta(rev):
            # can we use the cached delta?
            if cachedelta and cachedelta[0] == rev:
                delta = cachedelta[1]
            else:
                t = self._buildtext(node, p1, p2, btext, cachedelta, fh, flags)
                if self.iscensored(rev):
                    # deltas based on a censored revision must replace the
                    # full content in one patch, so delta works everywhere
                    header = mdiff.replacediffheader(self.rawsize(rev), len(t))
                    delta = header + t

                break

        if delta is not None:
            dist, l, data, base, chainbase, chainlen, compresseddeltalen = delta
        else:
            rawtext = self._buildtext(node, p1, p2, btext, cachedelta, fh,
                                      flags)
            data = self.compress(rawtext)
            l = len(data[1]) + len(data[0])
            base = chainbase = curr

        e = (offset_type(offset, flags), l, textlen,

        entry = self._io.packentry(e, self.node, self.version, curr)
        self._writeentry(transaction, ifh, dfh, entry, data, link, offset)

        if alwayscache and rawtext is None:
            rawtext = self._buildtext(node, p1, p2, btext, cachedelta, fh,
                                      flags)

        if type(rawtext) == str: # only accept immutable objects
            self._cache = (node, curr, rawtext)
        self._chainbasecache[curr] = chainbase
        return node