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

equal deleted inserted replaced

-:c3748f38dcd0
+:df50a1592e0c
 mode=b"w",
 checkambig=self.data_config.check_ambig,
 atomictemp=True,
 )
+def get_segment_for_revs(self, startrev, endrev):
+"""Obtain a segment of raw data corresponding to a range of revisions.
+Accepts the start and end revisions and an optional already-open
+file handle to be used for reading. If the file handle is read, its
+seek position will not be preserved.
+Requests for data may be satisfied by a cache.
+Returns a 2-tuple of (offset, data) for the requested range of
+revisions. Offset is the integer offset from the beginning of the
+revlog and data is a str or buffer of the raw byte data.
+Callers will need to call ``self.start(rev)`` and ``self.length(rev)``
+to determine where each revision's data begins and ends.
+API: we should consider making this a private part of the InnerRevlog
+at some point.
+"""
+# Inlined self.start(startrev) & self.end(endrev) for perf reasons
+# (functions are expensive).
+index = self.index
+istart = index[startrev]
+start = int(istart[0] >> 16)
+if startrev == endrev:
+end = start + istart[1]
+else:
+iend = index[endrev]
+end = int(iend[0] >> 16) + iend[1]
+if self.inline:
+start += (startrev + 1) * self.index.entry_size
+end += (endrev + 1) * self.index.entry_size
+length = end - start
+return start, self._segmentfile.read_chunk(start, length)
 class revlog:
 """
 the underlying revision storage object
 header |= self._format_version
 header |= FLAG_INLINE_DATA
 header = self.index.pack_header(header)
 idx = header + idx
 yield idx
-yield self._getsegmentforrevs(rev, rev)[1]
+yield self._inner.get_segment_for_revs(rev, rev)[1]
 inline_stream = get_stream()
 next(inline_stream)
 return [
 (self._indexfile, inline_stream, index_size + data_size),
 returns True if text is different than what is stored.
 """
 p1, p2 = self.parents(node)
 return storageutil.hashrevisionsha1(text, p1, p2) != node
-def _getsegmentforrevs(self, startrev, endrev):
-"""Obtain a segment of raw data corresponding to a range of revisions.
-Accepts the start and end revisions and an optional already-open
-file handle to be used for reading. If the file handle is read, its
-seek position will not be preserved.
-Requests for data may be satisfied by a cache.
-Returns a 2-tuple of (offset, data) for the requested range of
-revisions. Offset is the integer offset from the beginning of the
-revlog and data is a str or buffer of the raw byte data.
-Callers will need to call ``self.start(rev)`` and ``self.length(rev)``
-to determine where each revision's data begins and ends.
-"""
-# Inlined self.start(startrev) & self.end(endrev) for perf reasons
-# (functions are expensive).
-index = self.index
-istart = index[startrev]
-start = int(istart[0] >> 16)
-if startrev == endrev:
-end = start + istart[1]
-else:
-iend = index[endrev]
-end = int(iend[0] >> 16) + iend[1]
-if self._inline:
-start += (startrev + 1) * self.index.entry_size
-end += (endrev + 1) * self.index.entry_size
-length = end - start
-return start, self._inner._segmentfile.read_chunk(start, length)
 def _chunk(self, rev):
 """Obtain a single decompressed chunk for a revision.
 Accepts an integer revision and an optional already-open file handle
 to be used for reading. If used, the seek position of the file will not
 be preserved.
 Returns a str holding uncompressed data for the requested revision.
 """
 compression_mode = self.index[rev][10]
-data = self._getsegmentforrevs(rev, rev)[1]
+data = self._inner.get_segment_for_revs(rev, rev)[1]
 if compression_mode == COMP_MODE_PLAIN:
 return data
 elif compression_mode == COMP_MODE_DEFAULT:
 return self._decompressor(data)
 elif compression_mode == COMP_MODE_INLINE:
 for lastrev in revschunk[::-1]:
 if length(lastrev) != 0:
 break
 try:
-offset, data = self._getsegmentforrevs(firstrev, lastrev)
+offset, data = self._inner.get_segment_for_revs(
+firstrev,
+lastrev,
+)
 except OverflowError:
 # issue4215 - we can't cache a run of chunks greater than
 # 2G on Windows
 return [self._chunk(rev) for rev in revschunk]
 new_dfh = self._datafp(b'w+')
 new_dfh.truncate(0)  # drop any potentially existing data
 try:
 with self.reading():
 for r in self:
-new_dfh.write(self._getsegmentforrevs(r, r)[1])
+new_dfh.write(self._inner.get_segment_for_revs(r, r)[1])
 new_dfh.flush()
 if side_write:
 self._indexfile = new_index_file_path
 self._inner.index_file = self._indexfile

changeset 51084	df50a1592e0c
parent 51083	c3748f38dcd0
child 51085	31f143448704