Mercurial > public > mercurial-scm > hg-stable

comparison mercurial/revlog.py @ 3578:3b4e00cba57a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Define and use nullrev (revision of nullid) instead of -1.
author Thomas Arendsen Hein <thomas@intevation.de>
date Sun, 29 Oct 2006 10:53:51 +0100
parents 0aef94f45ebf
children 9fb7d3a05882
comparison
equal deleted inserted replaced
3577:7f7425306925 3578:3b4e00cba57a
100 self.s = struct.calcsize(indexformat) 100 self.s = struct.calcsize(indexformat)
101 self.indexformat = indexformat 101 self.indexformat = indexformat
102 self.datasize = size 102 self.datasize = size
103 self.l = size/self.s 103 self.l = size/self.s
104 self.index = [None] * self.l 104 self.index = [None] * self.l
105 self.map = {nullid: -1} 105 self.map = {nullid: nullrev}
106 self.allmap = 0 106 self.allmap = 0
107 self.all = 0 107 self.all = 0
108 self.mapfind_count = 0 108 self.mapfind_count = 0
109 self.shaoffset = shaoffset 109 self.shaoffset = shaoffset
110 110
385 e = list(self.index[0]) 385 e = list(self.index[0])
386 type = self.ngtype(e[0]) 386 type = self.ngtype(e[0])
387 e[0] = self.offset_type(0, type) 387 e[0] = self.offset_type(0, type)
388 self.index[0] = e 388 self.index[0] = e
389 else: 389 else:
390 self.nodemap = { nullid: -1} 390 self.nodemap = {nullid: nullrev}
391 self.index = [] 391 self.index = []
392 392
393 393
394 def parseindex(self, fp, st): 394 def parseindex(self, fp, st):
395 s = struct.calcsize(self.indexformat) 395 s = struct.calcsize(self.indexformat)
396 self.index = [] 396 self.index = []
397 self.nodemap = {nullid: -1} 397 self.nodemap = {nullid: nullrev}
398 inline = self.inlinedata() 398 inline = self.inlinedata()
399 n = 0 399 n = 0
400 leftover = None 400 leftover = None
401 while True: 401 while True:
402 if st: 402 if st:
472 try: 472 try:
473 return self.nodemap[node] 473 return self.nodemap[node]
474 except KeyError: 474 except KeyError:
475 raise RevlogError(_('%s: no node %s') % (self.indexfile, hex(node))) 475 raise RevlogError(_('%s: no node %s') % (self.indexfile, hex(node)))
476 def linkrev(self, node): 476 def linkrev(self, node):
477 return (node == nullid) and -1 or self.index[self.rev(node)][-4] 477 return (node == nullid) and nullrev or self.index[self.rev(node)][-4]
478 def parents(self, node): 478 def parents(self, node):
479 if node == nullid: return (nullid, nullid) 479 if node == nullid: return (nullid, nullid)
480 r = self.rev(node) 480 r = self.rev(node)
481 d = self.index[r][-3:-1] 481 d = self.index[r][-3:-1]
482 if self.version == REVLOGV0: 482 if self.version == REVLOGV0:
483 return d 483 return d
484 return (self.node(d[0]), self.node(d[1])) 484 return (self.node(d[0]), self.node(d[1]))
485 def parentrevs(self, rev): 485 def parentrevs(self, rev):
486 if rev == -1: 486 if rev == nullrev:
487 return (-1, -1) 487 return (nullrev, nullrev)
488 d = self.index[rev][-3:-1] 488 d = self.index[rev][-3:-1]
489 if self.version == REVLOGV0: 489 if self.version == REVLOGV0:
490 return (self.rev(d[0]), self.rev(d[1])) 490 return (self.rev(d[0]), self.rev(d[1]))
491 return d 491 return d
492 def start(self, rev): 492 def start(self, rev):
493 if rev < 0: 493 if rev < 0:
494 return -1 494 return nullrev
495 if self.version != REVLOGV0: 495 if self.version != REVLOGV0:
496 return self.ngoffset(self.index[rev][0]) 496 return self.ngoffset(self.index[rev][0])
497 return self.index[rev][0] 497 return self.index[rev][0]
498 498
499 def end(self, rev): return self.start(rev) + self.length(rev) 499 def end(self, rev): return self.start(rev) + self.length(rev)
579 if not roots: 579 if not roots:
580 return nonodes 580 return nonodes
581 lowestrev = min([self.rev(n) for n in roots]) 581 lowestrev = min([self.rev(n) for n in roots])
582 else: 582 else:
583 roots = [nullid] # Everybody's a descendent of nullid 583 roots = [nullid] # Everybody's a descendent of nullid
584 lowestrev = -1 584 lowestrev = nullrev
585 if (lowestrev == -1) and (heads is None): 585 if (lowestrev == nullrev) and (heads is None):
586 # We want _all_ the nodes! 586 # We want _all_ the nodes!
587 return ([self.node(r) for r in xrange(0, self.count())], 587 return ([self.node(r) for r in xrange(0, self.count())],
588 [nullid], list(self.heads())) 588 [nullid], list(self.heads()))
589 if heads is None: 589 if heads is None:
590 # All nodes are ancestors, so the latest ancestor is the last 590 # All nodes are ancestors, so the latest ancestor is the last
632 return nonodes 632 return nonodes
633 # Now that we have our set of ancestors, we want to remove any 633 # Now that we have our set of ancestors, we want to remove any
634 # roots that are not ancestors. 634 # roots that are not ancestors.
635 635
636 # If one of the roots was nullid, everything is included anyway. 636 # If one of the roots was nullid, everything is included anyway.
637 if lowestrev > -1: 637 if lowestrev > nullrev:
638 # But, since we weren't, let's recompute the lowest rev to not 638 # But, since we weren't, let's recompute the lowest rev to not
639 # include roots that aren't ancestors. 639 # include roots that aren't ancestors.
640 640
641 # Filter out roots that aren't ancestors of heads 641 # Filter out roots that aren't ancestors of heads
642 roots = [n for n in roots if n in ancestors] 642 roots = [n for n in roots if n in ancestors]
647 # No more roots? Return empty list 647 # No more roots? Return empty list
648 return nonodes 648 return nonodes
649 else: 649 else:
650 # We are descending from nullid, and don't need to care about 650 # We are descending from nullid, and don't need to care about
651 # any other roots. 651 # any other roots.
652 lowestrev = -1 652 lowestrev = nullrev
653 roots = [nullid] 653 roots = [nullid]
654 # Transform our roots list into a 'set' (i.e. a dictionary where the 654 # Transform our roots list into a 'set' (i.e. a dictionary where the
655 # values don't matter. 655 # values don't matter.
656 descendents = dict.fromkeys(roots, 1) 656 descendents = dict.fromkeys(roots, 1)
657 # Also, keep the original roots so we can filter out roots that aren't 657 # Also, keep the original roots so we can filter out roots that aren't
663 # and if nullid shows up in descedents, empty parents will look like 663 # and if nullid shows up in descedents, empty parents will look like
664 # they're descendents. 664 # they're descendents.
665 for r in xrange(max(lowestrev, 0), highestrev + 1): 665 for r in xrange(max(lowestrev, 0), highestrev + 1):
666 n = self.node(r) 666 n = self.node(r)
667 isdescendent = False 667 isdescendent = False
668 if lowestrev == -1: # Everybody is a descendent of nullid 668 if lowestrev == nullrev: # Everybody is a descendent of nullid
669 isdescendent = True 669 isdescendent = True
670 elif n in descendents: 670 elif n in descendents:
671 # n is already a descendent 671 # n is already a descendent
672 isdescendent = True 672 isdescendent = True
673 # This check only needs to be done here because all the roots 673 # This check only needs to be done here because all the roots
1054 1054
1055 def ancestor(self, a, b): 1055 def ancestor(self, a, b):
1056 """calculate the least common ancestor of nodes a and b""" 1056 """calculate the least common ancestor of nodes a and b"""
1057 1057
1058 def parents(rev): 1058 def parents(rev):
1059 return [p for p in self.parentrevs(rev) if p != -1] 1059 return [p for p in self.parentrevs(rev) if p != nullrev]
1060 1060
1061 c = ancestor.ancestor(self.rev(a), self.rev(b), parents) 1061 c = ancestor.ancestor(self.rev(a), self.rev(b), parents)
1062 if c is None: 1062 if c is None:
1063 return nullid 1063 return nullid
1064 1064
1111 #track the base of the current delta log 1111 #track the base of the current delta log
1112 r = self.count() 1112 r = self.count()
1113 t = r - 1 1113 t = r - 1
1114 node = None 1114 node = None
1115 1115
1116 base = prev = -1 1116 base = prev = nullrev
1117 start = end = textlen = 0 1117 start = end = textlen = 0
1118 if r: 1118 if r:
1119 end = self.end(t) 1119 end = self.end(t)
1120 1120
1121 ifh = self.opener(self.indexfile, "a+") 1121 ifh = self.opener(self.indexfile, "a+")