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

equal deleted inserted replaced

-:63799b01985c
+:11d12bd6e1dc
 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):
+def __init__(self, opener, indexfile, datafile, local=True):
 """
 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))
-# for each delta that isn't contiguous in the log, we need to
+if self.local:
-# reconstruct the base, reconstruct the result, and then
+mm = self.opener(self.datafile)
-# calculate the delta. We also need to do this where we've
+def chunk(r):
-# stored a full version and not a delta
+o = self.start(r)
-for i in xrange(0, len(revs) - 1):
+l = self.length(r)
-a, b = revs[i], revs[i + 1]
+mm.seek(o)
-if a + 1 != b or self.base(b) == b:
+return decompress(mm.read(l))
-for j in xrange(self.base(a), a + 1):
+else:
-needed[j] = 1
+# XXX: statichttp workaround
-for j in xrange(self.base(b), b + 1):
+needed = dict.fromkeys(revs[1:], 1)
-needed[j] = 1
+# for each delta that isn't contiguous in the log, we need to
+# reconstruct the base, reconstruct the result, and then
-# calculate spans to retrieve from datafile
+# calculate the delta. We also need to do this where we've
-needed = needed.keys()
+# stored a full version and not a delta
-needed.sort()
+for i in xrange(0, len(revs) - 1):
-spans = []
+a, b = revs[i], revs[i + 1]
-oo = -1
+if a + 1 != b or self.base(b) == b:
-ol = 0
+for j in xrange(self.base(a), a + 1):
-for n in needed:
+needed[j] = 1
-if n < 0: continue
+for j in xrange(self.base(b), b + 1):
-o = self.start(n)
+needed[j] = 1
-l = self.length(n)
-if oo + ol == o: # can we merge with the previous?
+# calculate spans to retrieve from datafile
-nl = spans[-1][2]
+needed = needed.keys()
-nl.append((n, l))
+needed.sort()
-ol += l
+spans = []
-spans[-1] = (oo, ol, nl)
+oo = -1
-else:
+ol = 0
-oo = o
+for n in needed:
-ol = l
+if n < 0: continue
-spans.append((oo, ol, [(n, l)]))
+o = self.start(n)
+l = self.length(n)
-# read spans in, divide up chunks
+if oo + ol == o: # can we merge with the previous?
-chunks = {}
+nl = spans[-1][2]
-for span in spans:
+nl.append((n, l))
-# we reopen the file for each span to make http happy for now
+ol += l
-f = self.opener(self.datafile)
+spans[-1] = (oo, ol, nl)
-f.seek(span[0])
+else:
-data = f.read(span[1])
+oo = o
+ol = l
-# divide up the span
+spans.append((oo, ol, [(n, l)]))
-pos = 0
-for r, l in span[2]:
+# read spans in, divide up chunks
-chunks[r] = decompress(data[pos: pos + l])
+chunks = {}
-pos += l
+for span in spans:
+# 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 = [chunks[r] for r in xrange(base + 1, rev + 1)]
+bins = [chunk(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 = chunks[self.base(a)]
+ta = chunk(self.base(a))
 ta = construct(ta, base, a)
 else:
 ta = ""
 base = self.base(b)
 if a > base:
 base = a
 tb = ta
 else:
-tb = chunks[self.base(b)]
+tb = chunk(self.base(b))
 tb = construct(tb, base, b)
 d = self.diff(ta, tb)
 else:
-d = chunks[b]
+d = chunk(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 1677	11d12bd6e1dc
parent 1559	59b3639df0a9
child 1678	b345cc4c22c0