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

equal deleted inserted replaced

-:c0df0cce64a4
+:ee983d0dbea8
 self.defversion = REVLOG_DEFAULT_VERSION
 if hasattr(opener, "defversion"):
 self.defversion = opener.defversion
 if self.defversion & REVLOGNG:
 self.defversion |= REVLOGNGINLINEDATA
-self.load()
+self._load()
-def load(self):
+def _load(self):
 v = self.defversion
 try:
 f = self.opener(self.indexfile)
 i = f.read(4)
 f.seek(0)
 else:
 self.indexformat = indexformatng
 shaoffset = ngshaoffset
 if i:
-if (lazyparser.safe_to_use and not self.inlinedata() and
+if (lazyparser.safe_to_use and not self._inline() and
 st and st.st_size > 10000):
 # big index, let's parse it on demand
 parser = lazyparser(f, st.st_size, self.indexformat, shaoffset)
 self.index = lazyindex(parser)
 self.nodemap = lazymap(parser)
 else:
-self.parseindex(f, st)
+self._parseindex(f, st)
 if self.version != REVLOGV0:
 e = list(self.index[0])
 type = gettype(e[0])
 e[0] = offset_type(0, type)
 self.index[0] = e
 else:
 self.nodemap = {nullid: nullrev}
 self.index = []
+def _parseindex(self, fp, st):
-def parseindex(self, fp, st):
 s = struct.calcsize(self.indexformat)
 self.index = []
 self.nodemap =  {nullid: nullrev}
-inline = self.inlinedata()
+inline = self._inline()
 n = 0
 leftover = None
 while True:
 if st:
 data = fp.read(65536)
 else:
 # hack for httprangereader, it doesn't do partial reads well
 data = fp.read()
 if not data:
 break
-if n == 0 and self.inlinedata():
+if n == 0 and self._inline():
 # cache the first chunk
 self.chunkcache = (0, data)
 if leftover:
 data = leftover + data
 leftover = None
 break
 if not st:
 break
-def loadindex(self, start, end):
+def _loadindex(self, start, end):
 """load a block of indexes all at once from the lazy parser"""
 if isinstance(self.index, lazyindex):
 self.index.p.loadindex(start, end)
-def loadindexmap(self):
+def _loadindexmap(self):
 """loads both the map and the index from the lazy parser"""
 if isinstance(self.index, lazyindex):
 p = self.index.p
 p.loadindex()
 self.nodemap = p.map
-def loadmap(self):
+def _loadmap(self):
 """loads the map from the lazy parser"""
 if isinstance(self.nodemap, lazymap):
 self.nodemap.p.loadmap()
 self.nodemap = self.nodemap.p.map
-def inlinedata(self): return self.version & REVLOGNGINLINEDATA
+def _inline(self): return self.version & REVLOGNGINLINEDATA
 def tip(self): return self.node(len(self.index) - 1)
 def count(self): return len(self.index)
 def node(self, rev):
 return rev == nullrev and nullid or self.index[rev][-1]
 def rev(self, node):
 """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.inlinedata()
+inline = self._inline()
 if inline:
 start += (rev + 1) * struct.calcsize(self.indexformat)
 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.inlinedata():
+if self._inline():
 # we probably have the whole chunk cached
 df = None
 else:
 df = self.opener(self.datafile)
 # do we have useful data cached?
 if self.cache and self.cache[1] >= base and self.cache[1] < rev:
 base = self.cache[1]
 text = self.cache[2]
-self.loadindex(base, rev + 1)
+self._loadindex(base, rev + 1)
 else:
-self.loadindex(base, rev + 1)
+self._loadindex(base, rev + 1)
 text = self.chunk(base, df=df)
 bins = []
 for r in xrange(base + 1, rev + 1):
 bins.append(self.chunk(r, df=df))
 self.cache = (node, rev, text)
 return text
 def checkinlinesize(self, tr, fp=None):
-if not self.inlinedata():
+if not self._inline():
 return
 if not fp:
 fp = self.opener(self.indexfile, 'r')
 fp.seek(0, 2)
 size = fp.tell()
 transaction - the transaction object used for rollback
 link - the linkrev data to add
 p1, p2 - the parent nodeids of the revision
 d - an optional precomputed delta
 """
-if not self.inlinedata():
+if not self._inline():
 dfh = self.opener(self.datafile, "a")
 else:
 dfh = None
 ifh = self.opener(self.indexfile, "a+")
 return self._addrevision(text, transaction, link, p1, p2, d, ifh, dfh)
 self.index.append(e)
 self.nodemap[node] = n
 entry = struct.pack(self.indexformat, *e)
-if not self.inlinedata():
+if not self._inline():
 transaction.add(self.datafile, offset)
 transaction.add(self.indexfile, n * len(entry))
 if data[0]:
 dfh.write(data[0])
 dfh.write(data[1])
 ifh.write(l)
 entry = entry[4:]
 ifh.write(entry)
-if self.inlinedata():
+if self._inline():
 ifh.write(data[0])
 ifh.write(data[1])
 self.checkinlinesize(transaction, ifh)
 self.cache = (node, n, text)
 end = self.end(t)
 ifh = self.opener(self.indexfile, "a+")
 ifh.seek(0, 2)
 transaction.add(self.indexfile, ifh.tell(), self.count())
-if self.inlinedata():
+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.inlinedata():
+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.append(e)
 self.nodemap[node] = r
-if self.inlinedata():
+if self._inline():
 ifh.write(struct.pack(self.indexformat, *e))
 ifh.write(cdelta)
 self.checkinlinesize(transaction, ifh)
-if not self.inlinedata():
+if not self._inline():
 dfh = self.opener(self.datafile, "a")
 ifh = self.opener(self.indexfile, "a")
 else:
 dfh.write(cdelta)
 ifh.write(struct.pack(self.indexformat, *e))
 def strip(self, rev, minlink):
 if self.count() == 0 or rev >= self.count():
 return
 if isinstance(self.index, lazyindex):
-self.loadindexmap()
+self._loadindexmap()
 # When stripping away a revision, we need to make sure it
 # does not actually belong to an older changeset.
 # The minlink parameter defines the oldest revision
 # we're allowed to strip away.
 if rev >= self.count():
 return
 # first truncate the files on disk
 end = self.start(rev)
-if not self.inlinedata():
+if not self._inline():
 df = self.opener(self.datafile, "a")
 df.truncate(end)
 end = rev * struct.calcsize(self.indexformat)
 else:
 end += rev * struct.calcsize(self.indexformat)
 f.seek(0, 2)
 actual = f.tell()
 s = struct.calcsize(self.indexformat)
 i = actual / s
 di = actual - (i * s)
-if self.inlinedata():
+if self._inline():
 databytes = 0
 for r in xrange(self.count()):
 databytes += self.length(r)
 dd = 0
 di = actual - self.count() * s - databytes

changeset 4964	ee983d0dbea8
parent 4963	c0df0cce64a4
child 4971	3e6dae278c99