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

annotate mercurial/revlog.py @ 1073:7b35a980b982

[PATCH] raise exceptions with Exception subclasses Fixed the patch. Using Exception subclasses. (tweaked by mpm)

author	Bart Trojanowski <bart@jukie.net>
date	Fri, 26 Aug 2005 19:08:25 -0700
parents	6d5a62a549fa
children	55bf5cfde69e

rev	line source
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	1 # revlog.py - storage back-end for mercurial
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	2 #
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	3 # This provides efficient delta storage with O(1) retrieve and append
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	4 # and O(changes) merge between branches
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	5 #
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	6 # Copyright 2005 Matt Mackall <mpm@selenic.com>
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	7 #
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	8 # This software may be used and distributed according to the terms
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	9 # of the GNU General Public License, incorporated herein by reference.
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	10
208 0a37e9c8ad6c revlog: remove some unnecessary imports mpm@selenic.com parents: 192 diff changeset	11 import zlib, struct, sha, binascii, heapq
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	12 from mercurial import mdiff
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	13
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	14 def hex(node): return binascii.hexlify(node)
da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	15 def bin(node): return binascii.unhexlify(node)
373 67081329d49a Change the size of the short hash representation mpm@selenic.com parents: 370 diff changeset	16 def short(node): return hex(node[:6])
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	17
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	18 def compress(text):
112 aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	19 if not text: return text
aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	20 if len(text) < 44:
aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	21 if text[0] == '\0': return text
aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	22 return 'u' + text
aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	23 bin = zlib.compress(text)
aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	24 if len(bin) > len(text):
aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	25 if text[0] == '\0': return text
aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	26 return 'u' + text
aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	27 return bin
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	28
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	29 def decompress(bin):
112 aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	30 if not bin: return bin
aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	31 t = bin[0]
aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	32 if t == '\0': return bin
aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	33 if t == 'x': return zlib.decompress(bin)
aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	34 if t == 'u': return bin[1:]
1073 7b35a980b982 [PATCH] raise exceptions with Exception subclasses Bart Trojanowski <bart@jukie.net> parents: 1062 diff changeset	35 raise RevlogError("unknown compression type %s" % t)
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	36
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	37 def hash(text, p1, p2):
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	38 l = [p1, p2]
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	39 l.sort()
531 0e9234a1a3f6 Hashing speed-up mpm@selenic.com parents: 515 diff changeset	40 s = sha.new(l[0])
0e9234a1a3f6 Hashing speed-up mpm@selenic.com parents: 515 diff changeset	41 s.update(l[1])
0e9234a1a3f6 Hashing speed-up mpm@selenic.com parents: 515 diff changeset	42 s.update(text)
0e9234a1a3f6 Hashing speed-up mpm@selenic.com parents: 515 diff changeset	43 return s.digest()
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	44
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	45 nullid = "\0" * 20
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	46 indexformat = ">4l20s20s20s"
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	47
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	48 class lazyparser:
323 c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	49 def __init__(self, data, revlog):
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	50 self.data = data
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	51 self.s = struct.calcsize(indexformat)
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	52 self.l = len(data)/self.s
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	53 self.index = [None] * self.l
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	54 self.map = {nullid: -1}
323 c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	55 self.all = 0
c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	56 self.revlog = revlog
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	57
323 c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	58 def load(self, pos=None):
c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	59 if self.all: return
c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	60 if pos is not None:
c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	61 block = pos / 1000
c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	62 i = block * 1000
c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	63 end = min(self.l, i + 1000)
c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	64 else:
c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	65 self.all = 1
c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	66 i = 0
c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	67 end = self.l
c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	68 self.revlog.index = self.index
c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	69 self.revlog.nodemap = self.map
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 484 diff changeset	70
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	71 while i < end:
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	72 d = self.data[i * self.s: (i + 1) * self.s]
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	73 e = struct.unpack(indexformat, d)
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	74 self.index[i] = e
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	75 self.map[e[6]] = i
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	76 i += 1
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 484 diff changeset	77
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	78 class lazyindex:
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	79 def __init__(self, parser):
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	80 self.p = parser
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	81 def __len__(self):
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	82 return len(self.p.index)
115 39b438eeb25a Make lazyindex load slightly faster mpm@selenic.com parents: 112 diff changeset	83 def load(self, pos):
39b438eeb25a Make lazyindex load slightly faster mpm@selenic.com parents: 112 diff changeset	84 self.p.load(pos)
39b438eeb25a Make lazyindex load slightly faster mpm@selenic.com parents: 112 diff changeset	85 return self.p.index[pos]
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	86 def __getitem__(self, pos):
115 39b438eeb25a Make lazyindex load slightly faster mpm@selenic.com parents: 112 diff changeset	87 return self.p.index[pos] or self.load(pos)
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	88 def append(self, e):
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	89 self.p.index.append(e)
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 484 diff changeset	90
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	91 class lazymap:
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	92 def __init__(self, parser):
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	93 self.p = parser
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	94 def load(self, key):
323 c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	95 if self.p.all: return
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	96 n = self.p.data.find(key)
86 1b945e8ba67b Friendlier exceptions for unknown node errors mpm@selenic.com parents: 84 diff changeset	97 if n < 0: raise KeyError("node " + hex(key))
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	98 pos = n / self.p.s
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	99 self.p.load(pos)
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	100 def __contains__(self, key):
323 c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	101 self.p.load()
c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	102 return key in self.p.map
97 7a2abee6b0c2 Add iterator to the lazymap code mpm@selenic.com parents: 94 diff changeset	103 def __iter__(self):
469 e205194ca7ef Various node id lookup tweaks mpm@selenic.com parents: 451 diff changeset	104 yield nullid
97 7a2abee6b0c2 Add iterator to the lazymap code mpm@selenic.com parents: 94 diff changeset	105 for i in xrange(self.p.l):
7a2abee6b0c2 Add iterator to the lazymap code mpm@selenic.com parents: 94 diff changeset	106 try:
7a2abee6b0c2 Add iterator to the lazymap code mpm@selenic.com parents: 94 diff changeset	107 yield self.p.index[i][6]
7a2abee6b0c2 Add iterator to the lazymap code mpm@selenic.com parents: 94 diff changeset	108 except:
7a2abee6b0c2 Add iterator to the lazymap code mpm@selenic.com parents: 94 diff changeset	109 self.p.load(i)
7a2abee6b0c2 Add iterator to the lazymap code mpm@selenic.com parents: 94 diff changeset	110 yield self.p.index[i][6]
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	111 def __getitem__(self, key):
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	112 try:
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	113 return self.p.map[key]
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	114 except KeyError:
86 1b945e8ba67b Friendlier exceptions for unknown node errors mpm@selenic.com parents: 84 diff changeset	115 try:
1b945e8ba67b Friendlier exceptions for unknown node errors mpm@selenic.com parents: 84 diff changeset	116 self.load(key)
1b945e8ba67b Friendlier exceptions for unknown node errors mpm@selenic.com parents: 84 diff changeset	117 return self.p.map[key]
1b945e8ba67b Friendlier exceptions for unknown node errors mpm@selenic.com parents: 84 diff changeset	118 except KeyError:
1b945e8ba67b Friendlier exceptions for unknown node errors mpm@selenic.com parents: 84 diff changeset	119 raise KeyError("node " + hex(key))
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	120 def __setitem__(self, key, val):
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	121 self.p.map[key] = val
d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	122
1073 7b35a980b982 [PATCH] raise exceptions with Exception subclasses Bart Trojanowski <bart@jukie.net> parents: 1062 diff changeset	123 class RevlogError(Exception): pass
7b35a980b982 [PATCH] raise exceptions with Exception subclasses Bart Trojanowski <bart@jukie.net> parents: 1062 diff changeset	124
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	125 class revlog:
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	126 def __init__(self, opener, indexfile, datafile):
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	127 self.indexfile = indexfile
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	128 self.datafile = datafile
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	129 self.opener = opener
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	130 self.cache = None
116 e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	131
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	132 try:
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	133 i = self.opener(self.indexfile).read()
73 ee1cbe841e01 Change revlog to use new patch code mpm@selenic.com parents: 71 diff changeset	134 except IOError:
76 d993ebd69d28 Add lazy{parser,index,map} to speed up processing of index files mpm@selenic.com parents: 73 diff changeset	135 i = ""
116 e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	136
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	137 if len(i) > 10000:
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	138 # big index, let's parse it on demand
323 c6f0673ab7e9 lazyparser speed ups mpm@selenic.com parents: 306 diff changeset	139 parser = lazyparser(i, self)
116 e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	140 self.index = lazyindex(parser)
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	141 self.nodemap = lazymap(parser)
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	142 else:
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	143 s = struct.calcsize(indexformat)
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	144 l = len(i) / s
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	145 self.index = [None] * l
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	146 m = [None] * l
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	147
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	148 n = 0
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	149 for f in xrange(0, len(i), s):
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	150 # offset, size, base, linkrev, p1, p2, nodeid
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	151 e = struct.unpack(indexformat, i[f:f + s])
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	152 m[n] = (e[6], n)
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	153 self.index[n] = e
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	154 n += 1
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	155
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	156 self.nodemap = dict(m)
e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	157 self.nodemap[nullid] = -1
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	158
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	159 def tip(self): return self.node(len(self.index) - 1)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	160 def count(self): return len(self.index)
26 9cf83bf9ad38 Simplify integrity checking mpm@selenic.com parents: 14 diff changeset	161 def node(self, rev): return (rev < 0) and nullid or self.index[rev][6]
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	162 def rev(self, node): return self.nodemap[node]
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	163 def linkrev(self, node): return self.index[self.nodemap[node]][3]
2 ecf3fd948051 Handle nullid better for ancestor mpm@selenic.com parents: 0 diff changeset	164 def parents(self, node):
ecf3fd948051 Handle nullid better for ancestor mpm@selenic.com parents: 0 diff changeset	165 if node == nullid: return (nullid, nullid)
ecf3fd948051 Handle nullid better for ancestor mpm@selenic.com parents: 0 diff changeset	166 return self.index[self.nodemap[node]][4:6]
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	167
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	168 def start(self, rev): return self.index[rev][0]
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	169 def length(self, rev): return self.index[rev][1]
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	170 def end(self, rev): return self.start(rev) + self.length(rev)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	171 def base(self, rev): return self.index[rev][2]
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	172
902 c749ca37aed1 Add optional stop revision to revlog.heads mason@suse.com parents: 896 diff changeset	173 def heads(self, stop=None):
221 2bfe525ef6ca Beginning of multi-head support mpm@selenic.com parents: 208 diff changeset	174 p = {}
2bfe525ef6ca Beginning of multi-head support mpm@selenic.com parents: 208 diff changeset	175 h = []
902 c749ca37aed1 Add optional stop revision to revlog.heads mason@suse.com parents: 896 diff changeset	176 stoprev = 0
c749ca37aed1 Add optional stop revision to revlog.heads mason@suse.com parents: 896 diff changeset	177 if stop and stop in self.nodemap:
c749ca37aed1 Add optional stop revision to revlog.heads mason@suse.com parents: 896 diff changeset	178 stoprev = self.rev(stop)
c749ca37aed1 Add optional stop revision to revlog.heads mason@suse.com parents: 896 diff changeset	179
243 9a9ea2d1d3c4 fix heads for rev 0 mpm@selenic.com parents: 241 diff changeset	180 for r in range(self.count() - 1, -1, -1):
221 2bfe525ef6ca Beginning of multi-head support mpm@selenic.com parents: 208 diff changeset	181 n = self.node(r)
2bfe525ef6ca Beginning of multi-head support mpm@selenic.com parents: 208 diff changeset	182 if n not in p:
2bfe525ef6ca Beginning of multi-head support mpm@selenic.com parents: 208 diff changeset	183 h.append(n)
902 c749ca37aed1 Add optional stop revision to revlog.heads mason@suse.com parents: 896 diff changeset	184 if n == stop:
c749ca37aed1 Add optional stop revision to revlog.heads mason@suse.com parents: 896 diff changeset	185 break
c749ca37aed1 Add optional stop revision to revlog.heads mason@suse.com parents: 896 diff changeset	186 if r < stoprev:
c749ca37aed1 Add optional stop revision to revlog.heads mason@suse.com parents: 896 diff changeset	187 break
221 2bfe525ef6ca Beginning of multi-head support mpm@selenic.com parents: 208 diff changeset	188 for pn in self.parents(n):
2bfe525ef6ca Beginning of multi-head support mpm@selenic.com parents: 208 diff changeset	189 p[pn] = 1
2bfe525ef6ca Beginning of multi-head support mpm@selenic.com parents: 208 diff changeset	190 return h
370 c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	191
c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	192 def children(self, node):
c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	193 c = []
c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	194 p = self.rev(node)
c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	195 for r in range(p + 1, self.count()):
c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	196 n = self.node(r)
c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	197 for pn in self.parents(n):
854 473c030d34a6 Fixed revlog.children. Tristan Wibberley <tristan@wibberley.org> parents: 655 diff changeset	198 if pn == node:
473c030d34a6 Fixed revlog.children. Tristan Wibberley <tristan@wibberley.org> parents: 655 diff changeset	199 c.append(n)
370 c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	200 continue
c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	201 elif pn == nullid:
c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	202 continue
c90385d82aec revlog: add a children function mpm@selenic.com parents: 330 diff changeset	203 return c
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 484 diff changeset	204
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	205 def lookup(self, id):
da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	206 try:
da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	207 rev = int(id)
469 e205194ca7ef Various node id lookup tweaks mpm@selenic.com parents: 451 diff changeset	208 if str(rev) != id: raise ValueError
e205194ca7ef Various node id lookup tweaks mpm@selenic.com parents: 451 diff changeset	209 if rev < 0: rev = self.count() + rev
476 0a338d506268 Really _call_ method revlog.count in revlog.lookup() Thomas Arendsen Hein <thomas@intevation.de> parents: 469 diff changeset	210 if rev < 0 or rev >= self.count(): raise ValueError
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	211 return self.node(rev)
469 e205194ca7ef Various node id lookup tweaks mpm@selenic.com parents: 451 diff changeset	212 except (ValueError, OverflowError):
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	213 c = []
da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	214 for n in self.nodemap:
469 e205194ca7ef Various node id lookup tweaks mpm@selenic.com parents: 451 diff changeset	215 if hex(n).startswith(id):
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	216 c.append(n)
da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	217 if len(c) > 1: raise KeyError("Ambiguous identifier")
67 a182f2561c8e Add tag support mpm@selenic.com parents: 65 diff changeset	218 if len(c) < 1: raise KeyError("No match found")
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	219 return c[0]
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 484 diff changeset	220
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	221 return None
da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	222
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	223 def diff(self, a, b):
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	224 return mdiff.textdiff(a, b)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	225
73 ee1cbe841e01 Change revlog to use new patch code mpm@selenic.com parents: 71 diff changeset	226 def patches(self, t, pl):
ee1cbe841e01 Change revlog to use new patch code mpm@selenic.com parents: 71 diff changeset	227 return mdiff.patches(t, pl)
ee1cbe841e01 Change revlog to use new patch code mpm@selenic.com parents: 71 diff changeset	228
119 c7a66f9752a4 Add code to retrieve or construct a revlog delta mpm@selenic.com parents: 117 diff changeset	229 def delta(self, node):
c7a66f9752a4 Add code to retrieve or construct a revlog delta mpm@selenic.com parents: 117 diff changeset	230 r = self.rev(node)
c7a66f9752a4 Add code to retrieve or construct a revlog delta mpm@selenic.com parents: 117 diff changeset	231 b = self.base(r)
c7a66f9752a4 Add code to retrieve or construct a revlog delta mpm@selenic.com parents: 117 diff changeset	232 if r == b:
c7a66f9752a4 Add code to retrieve or construct a revlog delta mpm@selenic.com parents: 117 diff changeset	233 return self.diff(self.revision(self.node(r - 1)),
c7a66f9752a4 Add code to retrieve or construct a revlog delta mpm@selenic.com parents: 117 diff changeset	234 self.revision(node))
c7a66f9752a4 Add code to retrieve or construct a revlog delta mpm@selenic.com parents: 117 diff changeset	235 else:
c7a66f9752a4 Add code to retrieve or construct a revlog delta mpm@selenic.com parents: 117 diff changeset	236 f = self.opener(self.datafile)
c7a66f9752a4 Add code to retrieve or construct a revlog delta mpm@selenic.com parents: 117 diff changeset	237 f.seek(self.start(r))
c7a66f9752a4 Add code to retrieve or construct a revlog delta mpm@selenic.com parents: 117 diff changeset	238 data = f.read(self.length(r))
c7a66f9752a4 Add code to retrieve or construct a revlog delta mpm@selenic.com parents: 117 diff changeset	239 return decompress(data)
c7a66f9752a4 Add code to retrieve or construct a revlog delta mpm@selenic.com parents: 117 diff changeset	240
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	241 def revision(self, node):
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	242 if node == nullid: return ""
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	243 if self.cache and self.cache[0] == node: return self.cache[2]
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	244
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	245 text = None
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	246 rev = self.rev(node)
117 2ac722ad1a9d Make revision code slightly faster mpm@selenic.com parents: 116 diff changeset	247 start, length, base, link, p1, p2, node = self.index[rev]
2ac722ad1a9d Make revision code slightly faster mpm@selenic.com parents: 116 diff changeset	248 end = start + length
2ac722ad1a9d Make revision code slightly faster mpm@selenic.com parents: 116 diff changeset	249 if base != rev: start = self.start(base)
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	250
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	251 if self.cache and self.cache[1] >= base and self.cache[1] < rev:
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	252 base = self.cache[1]
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	253 start = self.start(base + 1)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	254 text = self.cache[2]
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	255 last = 0
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	256
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	257 f = self.opener(self.datafile)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	258 f.seek(start)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	259 data = f.read(end - start)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	260
651 08b65d66f3e7 Fix an odd revlog bug Matt Mackall <mpm@selenic.com> parents: 644 diff changeset	261 if text is None:
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	262 last = self.length(base)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	263 text = decompress(data[:last])
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	264
71 47c9a869adee Add mdiff.patches to speed up applying thousands of patches to the manifest mpm@selenic.com parents: 67 diff changeset	265 bins = []
64 b3e2ddff0159 Diff in subdirectories from Jake Edge mpm@selenic.com parents: 46 diff changeset	266 for r in xrange(base + 1, rev + 1):
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	267 s = self.length(r)
71 47c9a869adee Add mdiff.patches to speed up applying thousands of patches to the manifest mpm@selenic.com parents: 67 diff changeset	268 bins.append(decompress(data[last:last + s]))
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	269 last = last + s
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	270
71 47c9a869adee Add mdiff.patches to speed up applying thousands of patches to the manifest mpm@selenic.com parents: 67 diff changeset	271 text = mdiff.patches(text, bins)
47c9a869adee Add mdiff.patches to speed up applying thousands of patches to the manifest mpm@selenic.com parents: 67 diff changeset	272
26 9cf83bf9ad38 Simplify integrity checking mpm@selenic.com parents: 14 diff changeset	273 if node != hash(text, p1, p2):
98 3dde7c87e36d Add paranoia to diff code mpm@selenic.com parents: 97 diff changeset	274 raise IOError("integrity check failed on %s:%d"
3dde7c87e36d Add paranoia to diff code mpm@selenic.com parents: 97 diff changeset	275 % (self.datafile, rev))
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	276
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	277 self.cache = (node, rev, text)
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 484 diff changeset	278 return text
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	279
644 6ebe118280bd Performance enhancements for manifest.add() mason@suse.com parents: 547 diff changeset	280 def addrevision(self, text, transaction, link, p1=None, p2=None, d=None):
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	281 if text is None: text = ""
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	282 if p1 is None: p1 = self.tip()
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	283 if p2 is None: p2 = nullid
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	284
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	285 node = hash(text, p1, p2)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	286
301 5add718d92db revlog: allow duplicates mpm@selenic.com parents: 243 diff changeset	287 if node in self.nodemap:
5add718d92db revlog: allow duplicates mpm@selenic.com parents: 243 diff changeset	288 return node
5add718d92db revlog: allow duplicates mpm@selenic.com parents: 243 diff changeset	289
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	290 n = self.count()
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	291 t = n - 1
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	292
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	293 if n:
64 b3e2ddff0159 Diff in subdirectories from Jake Edge mpm@selenic.com parents: 46 diff changeset	294 base = self.base(t)
b3e2ddff0159 Diff in subdirectories from Jake Edge mpm@selenic.com parents: 46 diff changeset	295 start = self.start(base)
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	296 end = self.end(t)
644 6ebe118280bd Performance enhancements for manifest.add() mason@suse.com parents: 547 diff changeset	297 if not d:
6ebe118280bd Performance enhancements for manifest.add() mason@suse.com parents: 547 diff changeset	298 prev = self.revision(self.tip())
6ebe118280bd Performance enhancements for manifest.add() mason@suse.com parents: 547 diff changeset	299 d = self.diff(prev, text)
98 3dde7c87e36d Add paranoia to diff code mpm@selenic.com parents: 97 diff changeset	300 data = compress(d)
64 b3e2ddff0159 Diff in subdirectories from Jake Edge mpm@selenic.com parents: 46 diff changeset	301 dist = end - start + len(data)
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	302
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	303 # full versions are inserted when the needed deltas
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	304 # become comparable to the uncompressed text
64 b3e2ddff0159 Diff in subdirectories from Jake Edge mpm@selenic.com parents: 46 diff changeset	305 if not n or dist > len(text) * 2:
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	306 data = compress(text)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	307 base = n
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	308 else:
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	309 base = self.base(t)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	310
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	311 offset = 0
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	312 if t >= 0:
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	313 offset = self.end(t)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	314
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	315 e = (offset, len(data), base, link, p1, p2, node)
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 484 diff changeset	316
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	317 self.index.append(e)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	318 self.nodemap[node] = n
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	319 entry = struct.pack(indexformat, *e)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	320
26 9cf83bf9ad38 Simplify integrity checking mpm@selenic.com parents: 14 diff changeset	321 transaction.add(self.datafile, e[0])
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	322 self.opener(self.datafile, "a").write(data)
41 df3f46253878 Fix truncate logic for indices again mpm@selenic.com parents: 36 diff changeset	323 transaction.add(self.indexfile, n * len(entry))
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	324 self.opener(self.indexfile, "a").write(entry)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	325
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	326 self.cache = (node, n, text)
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	327 return node
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	328
9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	329 def ancestor(self, a, b):
147 b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	330 # calculate the distance of every node from root
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	331 dist = {nullid: 0}
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	332 for i in xrange(self.count()):
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	333 n = self.node(i)
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	334 p1, p2 = self.parents(n)
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	335 dist[n] = max(dist[p1], dist[p2]) + 1
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 484 diff changeset	336
147 b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	337 # traverse ancestors in order of decreasing distance from root
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	338 def ancestors(node):
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	339 # we store negative distances because heap returns smallest member
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	340 h = [(-dist[node], node)]
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	341 seen = {}
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	342 earliest = self.count()
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	343 while h:
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	344 d, n = heapq.heappop(h)
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	345 if n not in seen:
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	346 seen[n] = 1
381 024ee0f8722a Ancestor algorithm fix mpm@selenic.com parents: 377 diff changeset	347 r = self.rev(n)
024ee0f8722a Ancestor algorithm fix mpm@selenic.com parents: 377 diff changeset	348 yield (-d, r, n)
147 b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	349 for p in self.parents(n):
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	350 heapq.heappush(h, (-dist[p], p))
45 f2b2d5daec30 Fix recursion depth trouble with ancestor algorithm mpm@selenic.com parents: 41 diff changeset	351
147 b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	352 x = ancestors(a)
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	353 y = ancestors(b)
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	354 lx = x.next()
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	355 ly = y.next()
45 f2b2d5daec30 Fix recursion depth trouble with ancestor algorithm mpm@selenic.com parents: 41 diff changeset	356
147 b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	357 # increment each ancestor list until it is closer to root than
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	358 # the other, or they match
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	359 while 1:
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	360 if lx == ly:
381 024ee0f8722a Ancestor algorithm fix mpm@selenic.com parents: 377 diff changeset	361 return lx[2]
147 b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	362 elif lx < ly:
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	363 ly = y.next()
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	364 elif lx > ly:
b6d8ed7aeba0 A new ancestor algorithm mpm@selenic.com parents: 126 diff changeset	365 lx = x.next()
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	366
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	367 def group(self, linkmap):
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	368 # given a list of changeset revs, return a set of deltas and
94 7daef883134f Refactor merge code mpm@selenic.com parents: 86 diff changeset	369 # metadata corresponding to nodes. the first delta is
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	370 # parent(nodes[0]) -> nodes[0] the receiver is guaranteed to
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	371 # have this parent as it has all history before these
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	372 # changesets. parent is parent[0]
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	373
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	374 revs = []
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	375 needed = {}
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	376
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	377 # find file nodes/revs that match changeset revs
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	378 for i in xrange(0, self.count()):
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	379 if self.index[i][3] in linkmap:
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	380 revs.append(i)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	381 needed[i] = 1
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	382
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	383 # if we don't have any revisions touched by these changesets, bail
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	384 if not revs:
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	385 yield struct.pack(">l", 0)
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	386 return
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	387
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	388 # add the parent of the first rev
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	389 p = self.parents(self.node(revs[0]))[0]
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	390 revs.insert(0, self.rev(p))
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	391
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	392 # for each delta that isn't contiguous in the log, we need to
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	393 # reconstruct the base, reconstruct the result, and then
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	394 # calculate the delta. We also need to do this where we've
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	395 # stored a full version and not a delta
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	396 for i in xrange(0, len(revs) - 1):
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	397 a, b = revs[i], revs[i + 1]
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	398 if a + 1 != b or self.base(b) == b:
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	399 for j in xrange(self.base(a), a + 1):
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	400 needed[j] = 1
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	401 for j in xrange(self.base(b), b + 1):
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	402 needed[j] = 1
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	403
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	404 # calculate spans to retrieve from datafile
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	405 needed = needed.keys()
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	406 needed.sort()
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	407 spans = []
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	408 oo = -1
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	409 ol = 0
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	410 for n in needed:
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	411 if n < 0: continue
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	412 o = self.start(n)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	413 l = self.length(n)
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	414 if oo + ol == o: # can we merge with the previous?
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	415 nl = spans[-1][2]
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	416 nl.append((n, l))
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	417 ol += l
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	418 spans[-1] = (oo, ol, nl)
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	419 else:
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	420 oo = o
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	421 ol = l
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	422 spans.append((oo, ol, [(n, l)]))
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	423
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	424 # read spans in, divide up chunks
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	425 chunks = {}
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	426 for span in spans:
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	427 # we reopen the file for each span to make http happy for now
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	428 f = self.opener(self.datafile)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	429 f.seek(span[0])
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	430 data = f.read(span[1])
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	431
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	432 # divide up the span
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	433 pos = 0
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	434 for r, l in span[2]:
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	435 chunks[r] = decompress(data[pos: pos + l])
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	436 pos += l
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	437
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	438 # helper to reconstruct intermediate versions
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	439 def construct(text, base, rev):
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	440 bins = [chunks[r] for r in xrange(base + 1, rev + 1)]
71 47c9a869adee Add mdiff.patches to speed up applying thousands of patches to the manifest mpm@selenic.com parents: 67 diff changeset	441 return mdiff.patches(text, bins)
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	442
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	443 # build deltas
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	444 deltas = []
71 47c9a869adee Add mdiff.patches to speed up applying thousands of patches to the manifest mpm@selenic.com parents: 67 diff changeset	445 for d in xrange(0, len(revs) - 1):
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	446 a, b = revs[d], revs[d + 1]
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	447 n = self.node(b)
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	448
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	449 # do we need to construct a new delta?
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	450 if a + 1 != b or self.base(b) == b:
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	451 if a >= 0:
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	452 base = self.base(a)
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	453 ta = chunks[self.base(a)]
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	454 ta = construct(ta, base, a)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	455 else:
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	456 ta = ""
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 484 diff changeset	457
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	458 base = self.base(b)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	459 if a > base:
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	460 base = a
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	461 tb = ta
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	462 else:
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	463 tb = chunks[self.base(b)]
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	464 tb = construct(tb, base, b)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	465 d = self.diff(ta, tb)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	466 else:
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	467 d = chunks[b]
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	468
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	469 p = self.parents(n)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	470 meta = n + p[0] + p[1] + linkmap[self.linkrev(n)]
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	471 l = struct.pack(">l", len(meta) + len(d) + 4)
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	472 yield l
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	473 yield meta
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	474 yield d
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	475
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	476 yield struct.pack(">l", 0)
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	477
1062 6d5a62a549fa pep-0008 cleanup benoit.boissinot@ens-lyon.fr parents: 902 diff changeset	478 def addgroup(self, revs, linkmapper, transaction, unique=0):
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	479 # given a set of deltas, add them to the revision log. the
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	480 # first delta is against its parent, which should be in our
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	481 # log, the rest are against the previous delta.
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	482
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	483 # track the base of the current delta log
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	484 r = self.count()
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	485 t = r - 1
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	486 node = nullid
515 03f27b1381f9 Whitespace cleanups mpm@selenic.com parents: 484 diff changeset	487
655 b3bba126b04a Fix out of range regression Matt Mackall <mpm@selenic.com> parents: 653 diff changeset	488 base = prev = -1
653 94cdd02792b5 Fix corruption resulting from skipping parts of a revision group Matt Mackall <mpm@selenic.com> parents: 651 diff changeset	489 start = end = measure = 0
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	490 if r:
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	491 start = self.start(self.base(t))
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	492 end = self.end(t)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	493 measure = self.length(self.base(t))
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	494 base = self.base(t)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	495 prev = self.tip()
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	496
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	497 transaction.add(self.datafile, end)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	498 transaction.add(self.indexfile, r * struct.calcsize(indexformat))
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	499 dfh = self.opener(self.datafile, "a")
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	500 ifh = self.opener(self.indexfile, "a")
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	501
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	502 # loop through our set of deltas
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	503 chain = None
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	504 for chunk in revs:
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	505 node, p1, p2, cs = struct.unpack("20s20s20s20s", chunk[:80])
94 7daef883134f Refactor merge code mpm@selenic.com parents: 86 diff changeset	506 link = linkmapper(cs)
77 bed15e766511 Fix bug in lazymap code mpm@selenic.com parents: 76 diff changeset	507 if node in self.nodemap:
224 ccbcc4d76f81 fix bad assumption about uniqueness of file versions mpm@selenic.com parents: 221 diff changeset	508 # this can happen if two branches make the same change
ccbcc4d76f81 fix bad assumption about uniqueness of file versions mpm@selenic.com parents: 221 diff changeset	509 if unique:
1073 7b35a980b982 [PATCH] raise exceptions with Exception subclasses Bart Trojanowski <bart@jukie.net> parents: 1062 diff changeset	510 raise RevlogError("already have %s" % hex(node[:4]))
653 94cdd02792b5 Fix corruption resulting from skipping parts of a revision group Matt Mackall <mpm@selenic.com> parents: 651 diff changeset	511 chain = node
224 ccbcc4d76f81 fix bad assumption about uniqueness of file versions mpm@selenic.com parents: 221 diff changeset	512 continue
192 5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	513 delta = chunk[80:]
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	514
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	515 if not chain:
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	516 # retrieve the parent revision of the delta chain
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	517 chain = p1
5d8553352d2e Changes to network protocol mpm@selenic.com parents: 155 diff changeset	518 if not chain in self.nodemap:
1073 7b35a980b982 [PATCH] raise exceptions with Exception subclasses Bart Trojanowski <bart@jukie.net> parents: 1062 diff changeset	519 raise RevlogError("unknown base %s" % short(chain[:4]))
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	520
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	521 # full versions are inserted when the needed deltas become
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	522 # comparable to the uncompressed text or when the previous
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	523 # version is not the one we have a delta against. We use
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	524 # the size of the previous full rev as a proxy for the
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	525 # current size.
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	526
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	527 if chain == prev:
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	528 cdelta = compress(delta)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	529
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	530 if chain != prev or (end - start + len(cdelta)) > measure * 2:
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	531 # flush our writes here so we can read it in revision
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	532 dfh.flush()
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	533 ifh.flush()
65 d40cc5aacc31 Fix up a bunch of bugs in the new merge code mpm@selenic.com parents: 64 diff changeset	534 text = self.revision(chain)
73 ee1cbe841e01 Change revlog to use new patch code mpm@selenic.com parents: 71 diff changeset	535 text = self.patches(text, [delta])
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	536 chk = self.addrevision(text, transaction, link, p1, p2)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	537 if chk != node:
1073 7b35a980b982 [PATCH] raise exceptions with Exception subclasses Bart Trojanowski <bart@jukie.net> parents: 1062 diff changeset	538 raise RevlogError("consistency error adding group")
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	539 measure = len(text)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	540 else:
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	541 e = (end, len(cdelta), self.base(t), link, p1, p2, node)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	542 self.index.append(e)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	543 self.nodemap[node] = r
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	544 dfh.write(cdelta)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	545 ifh.write(struct.pack(indexformat, *e))
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	546
65 d40cc5aacc31 Fix up a bunch of bugs in the new merge code mpm@selenic.com parents: 64 diff changeset	547 t, r, chain, prev = r, r + 1, node, node
46 93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	548 start = self.start(self.base(t))
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	549 end = self.end(t)
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	550
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	551 dfh.close()
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	552 ifh.close()
93e868fa0db8 Add changegroup support mpm@selenic.com parents: 45 diff changeset	553 return node

Mercurial > hg > mercurial-crew-with-dirclash

annotate mercurial/revlog.py @ 1073:7b35a980b982