mercurial-scm/hg: comparison mercurial/revlog.py

equal deleted inserted replaced

-:a7d39f08bc66
+:edc9330acac1
 wdirhex,
 wdirid,
 wdirrev,
 )
 from .i18n import _
+from .thirdparty import (
+attr,
+)
 from . import (
 ancestor,
 error,
 mdiff,
 policy,
 previdx = idx
 chunk = _trimchunk(revlog, revs, previdx)
 if chunk:
 yield chunk
+@attr.s(slots=True, frozen=True)
+class _deltainfo(object):
+distance = attr.ib()
+deltalen = attr.ib()
+data = attr.ib()
+base = attr.ib()
+chainbase = attr.ib()
+chainlen = attr.ib()
+compresseddeltalen = attr.ib()
 # index v0:
 #  4 bytes: offset
 #  4 bytes: compressed length
 #  4 bytes: base rev
 except KeyError:
 raise RevlogError(_('unknown compression type %r') % t)
 return compressor.decompress(data)
-def _isgooddelta(self, d, textlen):
+def _isgooddeltainfo(self, d, textlen):
 """Returns True if the given delta is good. Good means that it is within
 the disk span, disk size, and chain length bounds that we know to be
 performant."""
 if d is None:
 return False
-# - 'dist' is the distance from the base revision -- bounding it limits
+# - 'd.distance' is the distance from the base revision -- bounding it
-#   the amount of I/O we need to do.
+#   limits the amount of I/O we need to do.
-# - 'compresseddeltalen' is the sum of the total size of deltas we need
+# - 'd.compresseddeltalen' is the sum of the total size of deltas we
-#   to apply -- bounding it limits the amount of CPU we consume.
+#   need to apply -- bounding it limits the amount of CPU we consume.
-dist, l, data, base, chainbase, chainlen, compresseddeltalen = d
 defaultmax = textlen * 4
 maxdist = self._maxdeltachainspan
 if not maxdist:
-maxdist = dist # ensure the conditional pass
+maxdist = d.distance # ensure the conditional pass
 maxdist = max(maxdist, defaultmax)
-if (dist > maxdist or l > textlen or
+if (d.distance > maxdist or d.deltalen > textlen or
-compresseddeltalen > textlen * 2 or
+d.compresseddeltalen > textlen * 2 or
-(self._maxchainlen and chainlen > self._maxchainlen)):
+(self._maxchainlen and d.chainlen > self._maxchainlen)):
 return False
 return True
 def _getcandidaterevs(self, p1, p2, cachedelta):
 # must pass the censored index flag to add censored revisions
 if not flags & REVIDX_ISCENSORED:
 raise
 return btext[0]
-def _builddelta(self, node, rev, p1, p2, btext, cachedelta, fh, flags):
+def _builddeltainfo(self, node, rev, p1, p2, btext, cachedelta, fh, flags):
 # 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)
 else:
 base = chainbase
 chainlen, compresseddeltalen = self._chaininfo(rev)
 chainlen += 1
 compresseddeltalen += deltalen
-return (dist, deltalen, (header, data), base,
+return _deltainfo(dist, deltalen, (header, data), base,
 chainbase, chainlen, compresseddeltalen)
 def _addrevision(self, node, rawtext, transaction, link, p1, p2, flags,
 cachedelta, ifh, dfh, alwayscache=False):
 """internal function to add revisions to the log
 btext = [rawtext]
 curr = len(self)
 prev = curr - 1
 offset = self.end(prev)
-delta = None
+deltainfo = None
 p1r, p2r = self.rev(p1), self.rev(p2)
 # full versions are inserted when the needed deltas
 # become comparable to the uncompressed text
 if rawtext is None:
 textlen = len(rawtext)
 for candidaterevs in self._getcandidaterevs(p1, p2, cachedelta):
 nominateddeltas = []
 for candidaterev in candidaterevs:
-candidatedelta = self._builddelta(node, candidaterev, p1, p2,
+candidatedelta = self._builddeltainfo(node, candidaterev, p1,
-btext, cachedelta, fh,
+p2, btext, cachedelta,
-flags)
+fh, flags)
-if self._isgooddelta(candidatedelta, textlen):
+if self._isgooddeltainfo(candidatedelta, textlen):
 nominateddeltas.append(candidatedelta)
 if nominateddeltas:
-delta = min(nominateddeltas, key=lambda x: x[1])
+deltainfo = min(nominateddeltas, key=lambda x: x.deltalen)
 break
-if delta is not None:
+if deltainfo is not None:
-dist, l, data, base, chainbase, chainlen, compresseddeltalen = delta
+base = deltainfo.base
+chainbase = deltainfo.chainbase
+data = deltainfo.data
+l = deltainfo.deltalen
 else:
 rawtext = self._buildtext(node, p1, p2, btext, cachedelta, fh,
 flags)
 data = self.compress(rawtext)
 l = len(data[1]) + len(data[0])

changeset 35638	edc9330acac1
parent 35637	a7d39f08bc66
child 35639	30f5f33250c8