This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9231

revlog: extend addgroup() with callback for duplicates
ClosedPublic

Authored by joerg.sonnenberger on Oct 20 2020, 11:33 AM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHGa5206e71c536: revlog: extend addgroup() with callback for duplicates
Summary

The addgroup() interface currently doesn't allow the caller to keep
track of duplicated nodes except by looking at the returned node list.
Add an optional second callback for this purpose and change the return
type to a boolean. This allows follow-up changes to use more efficient
storage for the node list in places that are memory-sensitive.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

joerg.sonnenberger added a commit: rHGa5206e71c536: revlog: extend addgroup() with callback for duplicates.Oct 28 2020, 9:59 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGa5206e71c536: revlog: extend addgroup() with callback for duplicates (authored by joerg.sonnenberger). · Explain Why
This revision was automatically updated to reflect the committed changes.
martinvonz added a subscriber: martinvonz.Oct 28 2020, 11:52 PM

Like I just commented about on D9208, I think the consensus is that we want API changes documented in the release notes, so please send a follow-up with that.

Revision Contents
Changeset List

Diff 23342

hgext/sqlitestore.py

return node return node
def addgroup( def addgroup(
self, self,
deltas, deltas,
linkmapper, linkmapper,
transaction, transaction,
addrevisioncb=None, addrevisioncb=None,
duplicaterevisioncb=None,
maybemissingparents=False, maybemissingparents=False,
): ):
nodes = [] empty = True
for node, p1, p2, linknode, deltabase, delta, wireflags in deltas: for node, p1, p2, linknode, deltabase, delta, wireflags in deltas:
storeflags = 0 storeflags = 0
if wireflags & repository.REVISION_FLAG_CENSORED: if wireflags & repository.REVISION_FLAG_CENSORED:
storeflags |= FLAG_CENSORED storeflags |= FLAG_CENSORED
if wireflags & ~repository.REVISION_FLAG_CENSORED: if wireflags & ~repository.REVISION_FLAG_CENSORED:
if not (storeflags & FLAG_CENSORED) and storageutil.deltaiscensored( if not (storeflags & FLAG_CENSORED) and storageutil.deltaiscensored(
delta, baserev, lambda x: len(self.rawdata(x)) delta, baserev, lambda x: len(self.rawdata(x))
): ):
storeflags |= FLAG_CENSORED storeflags |= FLAG_CENSORED
linkrev = linkmapper(linknode) linkrev = linkmapper(linknode)
nodes.append(node)
if node in self._revisions: if node in self._revisions:
# Possibly reset parents to make them proper. # Possibly reset parents to make them proper.
entry = self._revisions[node] entry = self._revisions[node]
if entry.flags & FLAG_MISSING_P1 and p1 != nullid: if entry.flags & FLAG_MISSING_P1 and p1 != nullid:
entry.p1node = p1 entry.p1node = p1
entry.p1rev = self._nodetorev[p1] entry.p1rev = self._nodetorev[p1]
entry.flags &= ~FLAG_MISSING_P1 entry.flags &= ~FLAG_MISSING_P1
self._db.execute( self._db.execute(
'UPDATE fileindex SET p1rev=?, flags=? WHERE id=?', 'UPDATE fileindex SET p1rev=?, flags=? WHERE id=?',
(self._nodetorev[p1], entry.flags, entry.rid), (self._nodetorev[p1], entry.flags, entry.rid),
) )
if entry.flags & FLAG_MISSING_P2 and p2 != nullid: if entry.flags & FLAG_MISSING_P2 and p2 != nullid:
entry.p2node = p2 entry.p2node = p2
entry.p2rev = self._nodetorev[p2] entry.p2rev = self._nodetorev[p2]
entry.flags &= ~FLAG_MISSING_P2 entry.flags &= ~FLAG_MISSING_P2
self._db.execute( self._db.execute(
'UPDATE fileindex SET p2rev=?, flags=? WHERE id=?', 'UPDATE fileindex SET p2rev=?, flags=? WHERE id=?',
(self._nodetorev[p1], entry.flags, entry.rid), (self._nodetorev[p1], entry.flags, entry.rid),
) )
if duplicaterevisioncb:
duplicaterevisioncb(self, node)
empty = False
continue continue
if deltabase == nullid: if deltabase == nullid:
text = mdiff.patch(b'', delta) text = mdiff.patch(b'', delta)
storedelta = None storedelta = None
else: else:
text = None text = None
storedelta = (deltabase, delta) storedelta = (deltabase, delta)
self._addrawrevision( self._addrawrevision(
node, node,
text, text,
transaction, transaction,
linkrev, linkrev,
p1, p1,
p2, p2,
storedelta=storedelta, storedelta=storedelta,
flags=storeflags, flags=storeflags,
) )
if addrevisioncb: if addrevisioncb:
addrevisioncb(self, node) addrevisioncb(self, node)
empty = False
return nodes return not empty
def censorrevision(self, tr, censornode, tombstone=b''): def censorrevision(self, tr, censornode, tombstone=b''):
tombstone = storageutil.packmeta({b'censored': tombstone}, b'') tombstone = storageutil.packmeta({b'censored': tombstone}, b'')
# This restriction is cargo culted from revlogs and makes no sense for # This restriction is cargo culted from revlogs and makes no sense for
# SQLite, since columns can be resized at will. # SQLite, since columns can be resized at will.
if len(tombstone) > len(self.rawdata(censornode)): if len(tombstone) > len(self.rawdata(censornode)):
raise error.Abort( raise error.Abort(

mercurial/changegroup.py

repo.ui.status(_(b"adding changesets\n")) repo.ui.status(_(b"adding changesets\n"))
clstart = len(cl) clstart = len(cl)
progress = repo.ui.makeprogress( progress = repo.ui.makeprogress(
_(b'changesets'), unit=_(b'chunks'), total=expectedtotal _(b'changesets'), unit=_(b'chunks'), total=expectedtotal
) )
self.callback = progress.increment self.callback = progress.increment
efilesset = set() efilesset = set()
cgnodes = []
def onchangelog(cl, node): def onchangelog(cl, node):
efilesset.update(cl.readfiles(node)) efilesset.update(cl.readfiles(node))
cgnodes.append(node)
def ondupchangelog(cl, node):
cgnodes.append(node)
self.changelogheader() self.changelogheader()
deltas = self.deltaiter() deltas = self.deltaiter()
cgnodes = cl.addgroup(deltas, csmap, trp, addrevisioncb=onchangelog) if not cl.addgroup(
efiles = len(efilesset) deltas,
csmap,
if not cgnodes: trp,
addrevisioncb=onchangelog,
duplicaterevisioncb=ondupchangelog,
):
repo.ui.develwarn( repo.ui.develwarn(
b'applied empty changelog from changegroup', b'applied empty changelog from changegroup',
config=b'warn-empty-changegroup', config=b'warn-empty-changegroup',
) )
efiles = len(efilesset)
clend = len(cl) clend = len(cl)
changesets = clend - clstart changesets = clend - clstart
progress.complete() progress.complete()
del deltas del deltas
# TODO Python 2.7 removal # TODO Python 2.7 removal
# del efilesset # del efilesset
efilesset = None efilesset = None
self.callback = None self.callback = None

mercurial/exchangev2.py

# follows. # follows.
meta = next(objs) meta = next(objs)
progress = repo.ui.makeprogress( progress = repo.ui.makeprogress(
_(b'changesets'), unit=_(b'chunks'), total=meta.get(b'totalitems') _(b'changesets'), unit=_(b'chunks'), total=meta.get(b'totalitems')
) )
manifestnodes = {} manifestnodes = {}
added = []
def linkrev(node): def linkrev(node):
repo.ui.debug(b'add changeset %s\n' % short(node)) repo.ui.debug(b'add changeset %s\n' % short(node))
# Linkrev for changelog is always self. # Linkrev for changelog is always self.
return len(cl) return len(cl)
def ondupchangeset(cl, node):
added.append(node)
def onchangeset(cl, node): def onchangeset(cl, node):
progress.increment() progress.increment()
revision = cl.changelogrevision(node) revision = cl.changelogrevision(node)
added.append(node)
# We need to preserve the mapping of changelog revision to node # We need to preserve the mapping of changelog revision to node
# so we can set the linkrev accordingly when manifests are added. # so we can set the linkrev accordingly when manifests are added.
manifestnodes[cl.rev(node)] = revision.manifest manifestnodes[cl.rev(node)] = revision.manifest
nodesbyphase = {phase: set() for phase in phases.phasenames.values()} nodesbyphase = {phase: set() for phase in phases.phasenames.values()}
remotebookmarks = {} remotebookmarks = {}
cset[b'node'], cset[b'node'],
# We always send full revisions. So delta base is not set. # We always send full revisions. So delta base is not set.
nullid, nullid,
mdiff.trivialdiffheader(len(data)) + data, mdiff.trivialdiffheader(len(data)) + data,
# Flags not yet supported. # Flags not yet supported.
0, 0,
) )
added = cl.addgroup( cl.addgroup(
iterrevisions(), linkrev, weakref.proxy(tr), addrevisioncb=onchangeset iterrevisions(),
linkrev,
weakref.proxy(tr),
addrevisioncb=onchangeset,
duplicaterevisioncb=ondupchangeset,
) )
progress.complete() progress.complete()
return { return {
b'added': added, b'added': added,
b'nodesbyphase': nodesbyphase, b'nodesbyphase': nodesbyphase,
b'bookmarks': remotebookmarks, b'bookmarks': remotebookmarks,
b'fields': {b'parents', b'revision'}, b'fields': {b'parents', b'revision'},
b'haveparents': True, b'haveparents': True,
}, },
).result() ).result()
# Chomp off header object. # Chomp off header object.
next(objs) next(objs)
added.extend( def onchangeset(cl, node):
added.append(node)
rootmanifest.addgroup( rootmanifest.addgroup(
iterrevisions(objs, progress), iterrevisions(objs, progress),
linkrevs.__getitem__, linkrevs.__getitem__,
weakref.proxy(tr), weakref.proxy(tr),
) addrevisioncb=onchangeset,
duplicaterevisioncb=onchangeset,
) )
progress.complete() progress.complete()
return { return {
b'added': added, b'added': added,
b'linkrevs': linkrevs, b'linkrevs': linkrevs,
} }

mercurial/filelog.py

) )
def addgroup( def addgroup(
self, self,
deltas, deltas,
linkmapper, linkmapper,
transaction, transaction,
addrevisioncb=None, addrevisioncb=None,
duplicaterevisioncb=None,
maybemissingparents=False, maybemissingparents=False,
): ):
if maybemissingparents: if maybemissingparents:
raise error.Abort( raise error.Abort(
_( _(
b'revlog storage does not support missing ' b'revlog storage does not support missing '
b'parents write mode' b'parents write mode'
) )
) )
return self._revlog.addgroup( return self._revlog.addgroup(
deltas, linkmapper, transaction, addrevisioncb=addrevisioncb deltas,
linkmapper,
transaction,
addrevisioncb=addrevisioncb,
duplicaterevisioncb=duplicaterevisioncb,
) )
def getstrippoint(self, minlink): def getstrippoint(self, minlink):
return self._revlog.getstrippoint(minlink) return self._revlog.getstrippoint(minlink)
def strip(self, minlink, transaction): def strip(self, minlink, transaction):
return self._revlog.strip(minlink, transaction) return self._revlog.strip(minlink, transaction)

mercurial/interfaces/repository.py

applying raw data from a peer repo. applying raw data from a peer repo.
""" """
def addgroup( def addgroup(
deltas, deltas,
linkmapper, linkmapper,
transaction, transaction,
addrevisioncb=None, addrevisioncb=None,
duplicaterevisioncb=None,
maybemissingparents=False, maybemissingparents=False,
): ):
"""Process a series of deltas for storage. """Process a series of deltas for storage.
``deltas`` is an iterable of 7-tuples of ``deltas`` is an iterable of 7-tuples of
(node, p1, p2, linknode, deltabase, delta, flags) defining revisions (node, p1, p2, linknode, deltabase, delta, flags) defining revisions
to add. to add.
revisiondata=False, revisiondata=False,
assumehaveparentrevisions=False, assumehaveparentrevisions=False,
): ):
"""Produce ``irevisiondelta`` describing revisions. """Produce ``irevisiondelta`` describing revisions.
See the documentation for ``ifiledata`` for more. See the documentation for ``ifiledata`` for more.
""" """
def addgroup(deltas, linkmapper, transaction, addrevisioncb=None): def addgroup(
deltas,
linkmapper,
transaction,
addrevisioncb=None,
duplicaterevisioncb=None,
):
"""Process a series of deltas for storage. """Process a series of deltas for storage.
See the documentation in ``ifilemutation`` for more. See the documentation in ``ifilemutation`` for more.
""" """
def rawsize(rev): def rawsize(rev):
"""Obtain the size of tracked data. """Obtain the size of tracked data.

mercurial/manifest.py

return self._revlog.emitrevisions( return self._revlog.emitrevisions(
nodes, nodes,
nodesorder=nodesorder, nodesorder=nodesorder,
revisiondata=revisiondata, revisiondata=revisiondata,
assumehaveparentrevisions=assumehaveparentrevisions, assumehaveparentrevisions=assumehaveparentrevisions,
deltamode=deltamode, deltamode=deltamode,
) )
def addgroup(self, deltas, linkmapper, transaction, addrevisioncb=None): def addgroup(
self,
deltas,
linkmapper,
transaction,
addrevisioncb=None,
duplicaterevisioncb=None,
):
return self._revlog.addgroup( return self._revlog.addgroup(
deltas, linkmapper, transaction, addrevisioncb=addrevisioncb deltas,
linkmapper,
transaction,
addrevisioncb=addrevisioncb,
duplicaterevisioncb=duplicaterevisioncb,
) )
def rawsize(self, rev): def rawsize(self, rev):
return self._revlog.rawsize(rev) return self._revlog.rawsize(rev)
def getstrippoint(self, minlink): def getstrippoint(self, minlink):
return self._revlog.getstrippoint(minlink) return self._revlog.getstrippoint(minlink)

mercurial/revlog.py

offset += curr * self._io.size offset += curr * self._io.size
transaction.add(self.indexfile, offset, curr) transaction.add(self.indexfile, offset, curr)
ifh.write(entry) ifh.write(entry)
ifh.write(data[0]) ifh.write(data[0])
ifh.write(data[1]) ifh.write(data[1])
self._enforceinlinesize(transaction, ifh) self._enforceinlinesize(transaction, ifh)
nodemaputil.setup_persistent_nodemap(transaction, self) nodemaputil.setup_persistent_nodemap(transaction, self)
def addgroup(self, deltas, linkmapper, transaction, addrevisioncb=None): def addgroup(
self,
deltas,
linkmapper,
transaction,
addrevisioncb=None,
duplicaterevisioncb=None,
):
""" """
add a delta group add a delta group
given a set of deltas, add them to the revision log. the given a set of deltas, add them to the revision log. the
first delta is against its parent, which should be in our first delta is against its parent, which should be in our
log, the rest are against the previous delta. log, the rest are against the previous delta.
If ``addrevisioncb`` is defined, it will be called with arguments of If ``addrevisioncb`` is defined, it will be called with arguments of
this revlog and the node that was added. this revlog and the node that was added.
""" """
if self._writinghandles: if self._writinghandles:
raise error.ProgrammingError(b'cannot nest addgroup() calls') raise error.ProgrammingError(b'cannot nest addgroup() calls')
nodes = []
r = len(self) r = len(self)
end = 0 end = 0
if r: if r:
end = self.end(r - 1) end = self.end(r - 1)
ifh = self._indexfp(b"a+") ifh = self._indexfp(b"a+")
isize = r * self._io.size isize = r * self._io.size
if self._inline: if self._inline:
transaction.add(self.indexfile, end + isize, r) transaction.add(self.indexfile, end + isize, r)
dfh = None dfh = None
else: else:
transaction.add(self.indexfile, isize, r) transaction.add(self.indexfile, isize, r)
transaction.add(self.datafile, end) transaction.add(self.datafile, end)
dfh = self._datafp(b"a+") dfh = self._datafp(b"a+")
def flush(): def flush():
if dfh: if dfh:
dfh.flush() dfh.flush()
ifh.flush() ifh.flush()
self._writinghandles = (ifh, dfh) self._writinghandles = (ifh, dfh)
empty = True
try: try:
deltacomputer = deltautil.deltacomputer(self) deltacomputer = deltautil.deltacomputer(self)
# loop through our set of deltas # loop through our set of deltas
for data in deltas: for data in deltas:
node, p1, p2, linknode, deltabase, delta, flags = data node, p1, p2, linknode, deltabase, delta, flags = data
link = linkmapper(linknode) link = linkmapper(linknode)
flags = flags or REVIDX_DEFAULT_FLAGS flags = flags or REVIDX_DEFAULT_FLAGS
nodes.append(node)
if self.index.has_node(node): if self.index.has_node(node):
self._nodeduplicatecallback(transaction, node)
# this can happen if two branches make the same change # this can happen if two branches make the same change
self._nodeduplicatecallback(transaction, node)
if duplicaterevisioncb:
duplicaterevisioncb(self, node)
empty = False
continue continue
for p in (p1, p2): for p in (p1, p2):
if not self.index.has_node(p): if not self.index.has_node(p):
raise error.LookupError( raise error.LookupError(
p, self.indexfile, _(b'unknown parent') p, self.indexfile, _(b'unknown parent')
) )
ifh, ifh,
dfh, dfh,
alwayscache=bool(addrevisioncb), alwayscache=bool(addrevisioncb),
deltacomputer=deltacomputer, deltacomputer=deltacomputer,
) )
if addrevisioncb: if addrevisioncb:
addrevisioncb(self, node) addrevisioncb(self, node)
empty = False
if not dfh and not self._inline: if not dfh and not self._inline:
# addrevision switched from inline to conventional # addrevision switched from inline to conventional
# reopen the index # reopen the index
ifh.close() ifh.close()
dfh = self._datafp(b"a+") dfh = self._datafp(b"a+")
ifh = self._indexfp(b"a+") ifh = self._indexfp(b"a+")
self._writinghandles = (ifh, dfh) self._writinghandles = (ifh, dfh)
finally: finally:
self._writinghandles = None self._writinghandles = None
if dfh: if dfh:
dfh.close() dfh.close()
ifh.close() ifh.close()
return not empty
return nodes
def iscensored(self, rev): def iscensored(self, rev):
"""Check if a file revision is censored.""" """Check if a file revision is censored."""
if not self._censorable: if not self._censorable:
return False return False
return self.flags(rev) & REVIDX_ISCENSORED return self.flags(rev) & REVIDX_ISCENSORED

mercurial/testing/storage.py

def cb(*args, **kwargs): def cb(*args, **kwargs):
callbackargs.append((args, kwargs)) callbackargs.append((args, kwargs))
def linkmapper(node): def linkmapper(node):
return 0 return 0
with self._maketransactionfn() as tr: with self._maketransactionfn() as tr:
nodes = f.addgroup([], None, tr, addrevisioncb=cb) nodes = []
def onchangeset(cl, node):
nodes.append(node)
cb(cl, node)
def ondupchangeset(cl, node):
nodes.append(node)
f.addgroup(
[],
None,
tr,
addrevisioncb=onchangeset,
duplicaterevisioncb=ondupchangeset,
)
self.assertEqual(nodes, []) self.assertEqual(nodes, [])
self.assertEqual(callbackargs, []) self.assertEqual(callbackargs, [])
self.assertEqual(len(f), 0) self.assertEqual(len(f), 0)
fulltext0 = b'foo' fulltext0 = b'foo'
delta0 = mdiff.trivialdiffheader(len(fulltext0)) + fulltext0 delta0 = mdiff.trivialdiffheader(len(fulltext0)) + fulltext0
with self._maketransactionfn() as tr: with self._maketransactionfn() as tr:
node0 = f.add(fulltext0, None, tr, 0, nullid, nullid) node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)
f = self._makefilefn() f = self._makefilefn()
deltas = [ deltas = [
(node0, nullid, nullid, nullid, nullid, delta0, 0), (node0, nullid, nullid, nullid, nullid, delta0, 0),
] ]
with self._maketransactionfn() as tr: with self._maketransactionfn() as tr:
nodes = f.addgroup(deltas, linkmapper, tr, addrevisioncb=cb) nodes = []
def onchangeset(cl, node):
nodes.append(node)
cb(cl, node)
def ondupchangeset(cl, node):
nodes.append(node)
f.addgroup(
deltas,
linkmapper,
tr,
addrevisioncb=onchangeset,
duplicaterevisioncb=ondupchangeset,
)
self.assertEqual( self.assertEqual(
nodes, nodes,
[ [
b'\x49\xd8\xcb\xb1\x5c\xe2\x57\x92\x04\x47' b'\x49\xd8\xcb\xb1\x5c\xe2\x57\x92\x04\x47'
b'\x00\x6b\x46\x97\x8b\x7a\xf9\x80\xa9\x79' b'\x00\x6b\x46\x97\x8b\x7a\xf9\x80\xa9\x79'
], ],
) )
f = self._makefilefn() f = self._makefilefn()
deltas = [] deltas = []
for i, fulltext in enumerate(fulltexts): for i, fulltext in enumerate(fulltexts):
delta = mdiff.trivialdiffheader(len(fulltext)) + fulltext delta = mdiff.trivialdiffheader(len(fulltext)) + fulltext
deltas.append((nodes[i], nullid, nullid, nullid, nullid, delta, 0)) deltas.append((nodes[i], nullid, nullid, nullid, nullid, delta, 0))
with self._maketransactionfn() as tr: with self._maketransactionfn() as tr:
self.assertEqual(f.addgroup(deltas, lambda x: 0, tr), nodes) newnodes = []
def onchangeset(cl, node):
newnodes.append(node)
f.addgroup(
deltas,
lambda x: 0,
tr,
addrevisioncb=onchangeset,
duplicaterevisioncb=onchangeset,
)
self.assertEqual(newnodes, nodes)
self.assertEqual(len(f), len(deltas)) self.assertEqual(len(f), len(deltas))
self.assertEqual(list(f.revs()), [0, 1, 2]) self.assertEqual(list(f.revs()), [0, 1, 2])
self.assertEqual(f.rev(nodes[0]), 0) self.assertEqual(f.rev(nodes[0]), 0)
self.assertEqual(f.rev(nodes[1]), 1) self.assertEqual(f.rev(nodes[1]), 1)
self.assertEqual(f.rev(nodes[2]), 2) self.assertEqual(f.rev(nodes[2]), 2)
self.assertEqual(f.node(0), nodes[0]) self.assertEqual(f.node(0), nodes[0])
self.assertEqual(f.node(1), nodes[1]) self.assertEqual(f.node(1), nodes[1])

mercurial/unionrepo.py

raise NotImplementedError raise NotImplementedError
def addgroup( def addgroup(
self, self,
deltas, deltas,
linkmapper, linkmapper,
transaction, transaction,
addrevisioncb=None, addrevisioncb=None,
duplicaterevisioncb=None,
maybemissingparents=False, maybemissingparents=False,
): ):
raise NotImplementedError raise NotImplementedError
def strip(self, minlink, transaction): def strip(self, minlink, transaction):
raise NotImplementedError raise NotImplementedError
def checksize(self): def checksize(self):

tests/simplestorerepo.py

) )
def addgroup( def addgroup(
self, self,
deltas, deltas,
linkmapper, linkmapper,
transaction, transaction,
addrevisioncb=None, addrevisioncb=None,
duplicaterevisioncb=None,
maybemissingparents=False, maybemissingparents=False,
): ):
if maybemissingparents: if maybemissingparents:
raise error.Abort( raise error.Abort(
_('simple store does not support missing parents ' 'write mode') _('simple store does not support missing parents ' 'write mode')
) )
nodes = [] empty = True
transaction.addbackup(self._indexpath) transaction.addbackup(self._indexpath)
for node, p1, p2, linknode, deltabase, delta, flags in deltas: for node, p1, p2, linknode, deltabase, delta, flags in deltas:
linkrev = linkmapper(linknode) linkrev = linkmapper(linknode)
flags = flags or revlog.REVIDX_DEFAULT_FLAGS flags = flags or revlog.REVIDX_DEFAULT_FLAGS
nodes.append(node)
if node in self._indexbynode: if node in self._indexbynode:
if duplicaterevisioncb:
duplicaterevisioncb(self, node)
empty = False
continue continue
# Need to resolve the fulltext from the delta base. # Need to resolve the fulltext from the delta base.
if deltabase == nullid: if deltabase == nullid:
text = mdiff.patch(b'', delta) text = mdiff.patch(b'', delta)
else: else:
text = mdiff.patch(self.revision(deltabase), delta) text = mdiff.patch(self.revision(deltabase), delta)
self._addrawrevision( self._addrawrevision(
node, text, transaction, linkrev, p1, p2, flags node, text, transaction, linkrev, p1, p2, flags
) )
if addrevisioncb: if addrevisioncb:
addrevisioncb(self, node) addrevisioncb(self, node)
return nodes empty = False
return not empty
def _headrevs(self): def _headrevs(self):
# Assume all revisions are heads by default. # Assume all revisions are heads by default.
revishead = {rev: True for rev in self._indexbyrev} revishead = {rev: True for rev in self._indexbyrev}
for rev, entry in self._indexbyrev.items(): for rev, entry in self._indexbyrev.items():
# Unset head flag for all seen parents. # Unset head flag for all seen parents.
revishead[self.rev(entry[b'p1'])] = False revishead[self.rev(entry[b'p1'])] = False