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

equal deleted inserted replaced

-:11d12bd6e1dc
+:b345cc4c22c0
 Both pieces of the revlog are written to in an append-only
 fashion, which means we never need to rewrite a file to insert or
 remove data, and can use some simple techniques to avoid the need
 for locking while reading.
 """
-def __init__(self, opener, indexfile, datafile, local=True):
+def __init__(self, opener, indexfile, datafile):
 """
 create a revlog object
 opener is a function that abstracts the file opening operation
 and can be used to implement COW semantics or the like.
 """
 self.indexfile = indexfile
 self.datafile = datafile
 self.opener = opener
 self.cache = None
-self.local = local # XXX only needed because statichttp
 try:
 i = self.opener(self.indexfile).read()
 except IOError, inst:
 if inst.errno != errno.ENOENT:
 gy = y.next()
 else:
 #print "next x"
 gx = x.next()
-def group(self, nodelist, lookup, infocollect=None):
+def group(self, nodelist, lookup, infocollect = None):
 """calculate a delta group
 Given a list of changeset revs, return a set of deltas and
 metadata corresponding to nodes. the first delta is
 parent(nodes[0]) -> nodes[0] the receiver is guaranteed to
 have this parent as it has all history before these
 changesets. parent is parent[0]
 """
 revs = [self.rev(n) for n in nodelist]
+needed = dict.fromkeys(revs, 1)
 # if we don't have any revisions touched by these changesets, bail
 if not revs:
 yield struct.pack(">l", 0)
 return
 # add the parent of the first rev
 p = self.parents(self.node(revs[0]))[0]
 revs.insert(0, self.rev(p))
-if self.local:
+# for each delta that isn't contiguous in the log, we need to
-mm = self.opener(self.datafile)
+# reconstruct the base, reconstruct the result, and then
-def chunk(r):
+# calculate the delta. We also need to do this where we've
-o = self.start(r)
+# stored a full version and not a delta
-l = self.length(r)
+for i in xrange(0, len(revs) - 1):
-mm.seek(o)
+a, b = revs[i], revs[i + 1]
-return decompress(mm.read(l))
+if a + 1 != b or self.base(b) == b:
-else:
+for j in xrange(self.base(a), a + 1):
-# XXX: statichttp workaround
+needed[j] = 1
-needed = dict.fromkeys(revs[1:], 1)
+for j in xrange(self.base(b), b + 1):
-# for each delta that isn't contiguous in the log, we need to
+needed[j] = 1
-# reconstruct the base, reconstruct the result, and then
-# calculate the delta. We also need to do this where we've
+# calculate spans to retrieve from datafile
-# stored a full version and not a delta
+needed = needed.keys()
-for i in xrange(0, len(revs) - 1):
+needed.sort()
-a, b = revs[i], revs[i + 1]
+spans = []
-if a + 1 != b or self.base(b) == b:
+oo = -1
-for j in xrange(self.base(a), a + 1):
+ol = 0
-needed[j] = 1
+for n in needed:
-for j in xrange(self.base(b), b + 1):
+if n < 0: continue
-needed[j] = 1
+o = self.start(n)
+l = self.length(n)
-# calculate spans to retrieve from datafile
+if oo + ol == o: # can we merge with the previous?
-needed = needed.keys()
+nl = spans[-1][2]
-needed.sort()
+nl.append((n, l))
-spans = []
+ol += l
-oo = -1
+spans[-1] = (oo, ol, nl)
-ol = 0
+else:
-for n in needed:
+oo = o
-if n < 0: continue
+ol = l
-o = self.start(n)
+spans.append((oo, ol, [(n, l)]))
-l = self.length(n)
-if oo + ol == o: # can we merge with the previous?
+# read spans in, divide up chunks
-nl = spans[-1][2]
+chunks = {}
-nl.append((n, l))
+for span in spans:
-ol += l
+# we reopen the file for each span to make http happy for now
-spans[-1] = (oo, ol, nl)
+f = self.opener(self.datafile)
-else:
+f.seek(span[0])
-oo = o
+data = f.read(span[1])
-ol = l
-spans.append((oo, ol, [(n, l)]))
+# divide up the span
+pos = 0
-# read spans in, divide up chunks
+for r, l in span[2]:
-chunks = {}
+chunks[r] = decompress(data[pos: pos + l])
-for span in spans:
+pos += l
-# we reopen the file for each span to make http happy for now
-f = self.opener(self.datafile)
-f.seek(span[0])
-data = f.read(span[1])
-# divide up the span
-pos = 0
-for r, l in span[2]:
-chunks[r] = decompress(data[pos: pos + l])
-pos += l
-def chunk(r):
-return chunks[r]
 # helper to reconstruct intermediate versions
 def construct(text, base, rev):
-bins = [chunk(r) for r in xrange(base + 1, rev + 1)]
+bins = [chunks[r] for r in xrange(base + 1, rev + 1)]
 return mdiff.patches(text, bins)
 # build deltas
+deltas = []
 for d in xrange(0, len(revs) - 1):
 a, b = revs[d], revs[d + 1]
 n = self.node(b)
 if infocollect is not None:
 # do we need to construct a new delta?
 if a + 1 != b or self.base(b) == b:
 if a >= 0:
 base = self.base(a)
-ta = chunk(self.base(a))
+ta = chunks[self.base(a)]
 ta = construct(ta, base, a)
 else:
 ta = ""
 base = self.base(b)
 if a > base:
 base = a
 tb = ta
 else:
-tb = chunk(self.base(b))
+tb = chunks[self.base(b)]
 tb = construct(tb, base, b)
 d = self.diff(ta, tb)
 else:
-d = chunk(b)
+d = chunks[b]
 p = self.parents(n)
 meta = n + p[0] + p[1] + lookup(n)
 l = struct.pack(">l", len(meta) + len(d) + 4)
 yield l

changeset 1678	b345cc4c22c0
parent 1677	11d12bd6e1dc
child 1680	c21b54f7f7b8