mercurial-crew-with-dirclash: comparison mercurial/revlog.py

equal deleted inserted replaced

-:e7131935fbb3
+:9672e3c42b0c
 % (self.indexfile, flags >> 16))
 else:
 raise RevlogError(_("index %s unknown format %d")
 % (self.indexfile, fmt))
 self.version = v
+self._inline = v & REVLOGNGINLINEDATA
 self.nodemap = {nullid: nullrev}
 self.index = []
 self._io = revlogio()
 if self.version == REVLOGV0:
 self._io = revlogoldio()
 if i:
-self.index, self.nodemap = self._io.parseindex(f, st, self._inline())
+self.index, self.nodemap = self._io.parseindex(f, st, self._inline)
 # add the magic null revision at -1
 self.index.append((0, 0, 0, -1, -1, -1, -1, nullid))
 def _loadindex(self, start, end):
 """load a block of indexes all at once from the lazy parser"""
 """loads the map from the lazy parser"""
 if isinstance(self.nodemap, lazymap):
 self.nodemap.p.loadmap()
 self.nodemap = self.nodemap.p.map
-def _inline(self):
-return self.version & REVLOGNGINLINEDATA
 def tip(self):
 return self.node(len(self.index) - 2)
 def count(self):
 return len(self.index) - 1
 """apply a list of patches to a string"""
 return mdiff.patches(t, pl)
 def chunk(self, rev, df=None, cachelen=4096):
 start, length = self.start(rev), self.length(rev)
-inline = self._inline()
+inline = self._inline
 if inline:
 start += (rev + 1) * self._io.size
 end = start + length
 def loadcache(df):
 cache_length = max(cachelen, length) # 4k
 # look up what we need to read
 text = None
 rev = self.rev(node)
 base = self.base(rev)
-if self._inline():
+if self._inline:
 # we probably have the whole chunk cached
 df = None
 else:
 df = self.opener(self.datafile)
 self.cache = (node, rev, text)
 return text
 def checkinlinesize(self, tr, fp=None):
-if not self._inline():
+if not self._inline:
 return
 if not fp:
 fp = self.opener(self.indexfile, 'r')
 fp.seek(0, 2)
 size = fp.tell()
 df.write(d)
 fp.close()
 df.close()
 fp = self.opener(self.indexfile, 'w', atomictemp=True)
 self.version &= ~(REVLOGNGINLINEDATA)
+self._inline = False
 if self.count():
 x = self.index[0]
 e = struct.pack(indexformatng, *x)[4:]
 l = struct.pack(versionformat, self.version)
 fp.write(l)
 link - the linkrev data to add
 p1, p2 - the parent nodeids of the revision
 d - an optional precomputed delta
 """
 dfh = None
-if not self._inline():
+if not self._inline:
 dfh = self.opener(self.datafile, "a")
 ifh = self.opener(self.indexfile, "a+")
 return self._addrevision(text, transaction, link, p1, p2, d, ifh, dfh)
 def _addrevision(self, text, transaction, link, p1, p2, d, ifh, dfh):
 else:
 entry = struct.pack(indexformatng, *e)
 if not curr:
 entry = struct.pack(versionformat, self.version) + entry[4:]
-if not self._inline():
+if not self._inline:
 transaction.add(self.datafile, offset)
 transaction.add(self.indexfile, curr * len(entry))
 if data[0]:
 dfh.write(data[0])
 dfh.write(data[1])
 end = self.end(t)
 ifh = self.opener(self.indexfile, "a+")
 ifh.seek(0, 2)
 transaction.add(self.indexfile, ifh.tell(), self.count())
-if self._inline():
+if self._inline:
 dfh = None
 else:
 transaction.add(self.datafile, end)
 dfh = self.opener(self.datafile, "a")
 ifh.flush()
 text = self.revision(chain)
 text = self.patches(text, [delta])
 chk = self._addrevision(text, transaction, link, p1, p2, None,
 ifh, dfh)
-if not dfh and not self._inline():
+if not dfh and not self._inline:
 # addrevision switched from inline to conventional
 # reopen the index
 dfh = self.opener(self.datafile, "a")
 ifh = self.opener(self.indexfile, "a")
 if chk != node:
 else:
 e = (offset_type(end, 0), len(cdelta), textlen, base,
 link, self.rev(p1), self.rev(p2), node)
 self.index.insert(-1, e)
 self.nodemap[node] = r
-if self._inline():
+if self._inline:
 ifh.write(struct.pack(indexformatng, *e))
 ifh.write(cdelta)
 self.checkinlinesize(transaction, ifh)
-if not self._inline():
+if not self._inline:
 dfh = self.opener(self.datafile, "a")
 ifh = self.opener(self.indexfile, "a")
 else:
 if self.version == REVLOGV0:
 e = (end, len(cdelta), base, link, p1, p2, node)
 if rev >= self.count():
 return
 # first truncate the files on disk
 end = self.start(rev)
-if not self._inline():
+if not self._inline:
 df = self.opener(self.datafile, "a")
 df.truncate(end)
 end = rev * self._io.size
 else:
 end += rev * self._io.size
 f.seek(0, 2)
 actual = f.tell()
 s = self._io.size
 i = actual / s
 di = actual - (i * s)
-if self._inline():
+if self._inline:
 databytes = 0
 for r in xrange(self.count()):
 databytes += self.length(r)
 dd = 0
 di = actual - self.count() * s - databytes

changeset 4982	9672e3c42b0c
parent 4981	e7131935fbb3
child 4983	4dbcfc6e359e