mercurial: comparison mercurial/revlog.py

equal deleted inserted replaced

-:51b0e799352f
+:fb42030d79d6
 self.nodemap.p.loadmap()
 self.nodemap = self.nodemap.p.map
 def tip(self):
 return self.node(len(self.index) - 2)
-def count(self):
+def __len__(self):
 return len(self.index) - 1
+def __iter__(self):
+for i in xrange(len(self)):
+yield i
 def rev(self, node):
 try:
 return self.nodemap[node]
 except KeyError:
 raise LookupError(node, self.indexfile, _('no node'))
 else:
 roots = [nullid] # Everybody's a descendent of nullid
 lowestrev = nullrev
 if (lowestrev == nullrev) and (heads is None):
 # We want _all_ the nodes!
-return ([self.node(r) for r in xrange(0, self.count())],
+return ([self.node(r) for r in self], [nullid], list(self.heads()))
-[nullid], list(self.heads()))
 if heads is None:
 # All nodes are ancestors, so the latest ancestor is the last
 # node.
-highestrev = self.count() - 1
+highestrev = len(self) - 1
 # Set ancestors to None to signal that every node is an ancestor.
 ancestors = None
 # Set heads to an empty dictionary for later discovery of heads
 heads = {}
 else:
 start will be returned
 if stop is specified, it will consider all the revs from stop
 as if they had no children
 """
 if start is None and stop is None:
-count = self.count()
+count = len(self)
 if not count:
 return [nullid]
 ishead = [1] * (count + 1)
 index = self.index
-for r in xrange(count):
+for r in self:
 e = index[r]
 ishead[e[5]] = ishead[e[6]] = 0
-return [self.node(r) for r in xrange(count) if ishead[r]]
+return [self.node(r) for r in self if ishead[r]]
 if start is None:
 start = nullid
 if stop is None:
 stop = []
 startrev = self.rev(start)
 reachable = {startrev: 1}
 heads = {startrev: 1}
 parentrevs = self.parentrevs
-for r in xrange(startrev + 1, self.count()):
+for r in xrange(startrev + 1, len(self)):
 for p in parentrevs(r):
 if p in reachable:
 if r not in stoprevs:
 reachable[r] = 1
 heads[r] = 1
 def children(self, node):
 """find the children of a given node"""
 c = []
 p = self.rev(node)
-for r in range(p + 1, self.count()):
+for r in range(p + 1, len(self)):
 prevs = [pr for pr in self.parentrevs(r) if pr != nullrev]
 if prevs:
 for pr in prevs:
 if pr == p:
 c.append(self.node(r))
 # str(rev)
 rev = int(id)
 if str(rev) != id:
 raise ValueError
 if rev < 0:
-rev = self.count() + rev
+rev = len(self) + rev
-if rev < 0 or rev >= self.count():
+if rev < 0 or rev >= len(self):
 raise ValueError
 return self.node(rev)
 except (ValueError, OverflowError):
 pass
 if len(id) == 40:
 tr.add(self.datafile, dataoff)
 df = self.opener(self.datafile, 'w')
 try:
 calc = self._io.size
-for r in xrange(self.count()):
+for r in self:
 start = self.start(r) + (r + 1) * calc
 length = self.length(r)
 fp.seek(start)
 d = fp.read(length)
 df.write(d)
 fp.close()
 fp = self.opener(self.indexfile, 'w', atomictemp=True)
 self.version &= ~(REVLOGNGINLINEDATA)
 self._inline = False
-for i in xrange(self.count()):
+for i in self:
 e = self._io.packentry(self.index[i], self.node, self.version, i)
 fp.write(e)
 # if we don't call rename, the temp file will never replace the
 # real index
 def _addrevision(self, text, transaction, link, p1, p2, d, ifh, dfh):
 node = hash(text, p1, p2)
 if node in self.nodemap:
 return node
-curr = self.count()
+curr = len(self)
 prev = curr - 1
 base = self.base(prev)
 offset = self.end(prev)
 if curr:
 first delta is against its parent, which should be in our
 log, the rest are against the previous delta.
 """
 #track the base of the current delta log
-r = self.count()
+r = len(self)
 t = r - 1
 node = None
 base = prev = nullrev
 start = end = textlen = 0
 So we truncate the revlog on the first of these revisions, and
 trust that the caller has saved the revisions that shouldn't be
 removed and that it'll readd them after this truncation.
 """
-if self.count() == 0:
+if len(self) == 0:
 return
 if isinstance(self.index, lazyindex):
 self._loadindexmap()
-for rev in xrange(0, self.count()):
+for rev in self:
 if self.index[rev][4] >= minlink:
 break
 else:
 return
 indexf.truncate(end)
 # then reset internal state in memory to forget those revisions
 self._cache = None
 self._chunkcache = None
-for x in xrange(rev, self.count()):
+for x in xrange(rev, len(self)):
 del self.nodemap[self.node(x)]
 del self.index[rev:-1]
 def checksize(self):
 expected = 0
-if self.count():
+if len(self):
-expected = max(0, self.end(self.count() - 1))
+expected = max(0, self.end(len(self) - 1))
 try:
 f = self.opener(self.datafile)
 f.seek(0, 2)
 actual = f.tell()
 s = self._io.size
 i = max(0, actual / s)
 di = actual - (i * s)
 if self._inline:
 databytes = 0
-for r in xrange(self.count()):
+for r in self:
 databytes += max(0, self.length(r))
 dd = 0
-di = actual - self.count() * s - databytes
+di = actual - len(self) * s - databytes
 except IOError, inst:
 if inst.errno != errno.ENOENT:
 raise
 di = 0

changeset 6750	fb42030d79d6
parent 6703	bacfee67c1a9
child 6872	c7cc40fd74f6