This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4328

dagutil: use revlog.parentrevs() for resolving parent revisions
ClosedPublic

Authored by indygreg on Aug 17 2018, 5:31 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG8de526995844: dagutil: use revlog.parentrevs() for resolving parent revisions
Summary

And remove parents() since it is no longer used.

revlog.parentrevs() is almost the same as parents(). The main
difference is that parentrevs() can return nullrev. dagop.headrevs()
already handles nullrev. We add an inline check for nullrev in the
other call site to account for the difference.

.. api:: parents() removed from dagutil classes

Use parentrevs() on the storage object instead.

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.

Revision Contents
Changeset List

PathPackages
Mmercurial/dagutil.py (21 lines)

Diff 10448

mercurial/dagutil.py

) )
class revlogdag(object): class revlogdag(object):
'''dag interface to a revlog''' '''dag interface to a revlog'''
def __init__(self, revlog): def __init__(self, revlog):
self._revlog = revlog self._revlog = revlog
def parents(self, ix):
rlog = self._revlog
idx = rlog.index
revdata = idx[ix]
prev = revdata[5]
if prev != nullrev:
prev2 = revdata[6]
if prev2 == nullrev:
return [prev]
return [prev, prev2]
prev2 = revdata[6]
if prev2 != nullrev:
return [prev2]
return []
def linearize(self, ixs): def linearize(self, ixs):
'''linearize and topologically sort a list of revisions '''linearize and topologically sort a list of revisions
The linearization process tries to create long runs of revs where The linearization process tries to create long runs of revs where
a child rev comes immediately after its first parent. This is done by a child rev comes immediately after its first parent. This is done by
visiting the heads of the given revs in inverse topological order, visiting the heads of the given revs in inverse topological order,
and for each visited rev, visiting its second parent, then its first and for each visited rev, visiting its second parent, then its first
parent, then adding the rev itself to the output list. parent, then adding the rev itself to the output list.
''' '''
sorted = [] sorted = []
visit = list(dagop.headrevs(ixs, self.parents)) visit = list(dagop.headrevs(ixs, self._revlog.parentrevs))
visit.sort(reverse=True) visit.sort(reverse=True)
finished = set() finished = set()
while visit: while visit:
cur = visit.pop() cur = visit.pop()
if cur < 0: if cur < 0:
cur = -cur - 1 cur = -cur - 1
if cur not in finished: if cur not in finished:
sorted.append(cur) sorted.append(cur)
finished.add(cur) finished.add(cur)
else: else:
visit.append(-cur - 1) visit.append(-cur - 1)
visit += [p for p in self.parents(cur) visit += [p for p in self._revlog.parentrevs(cur)
if p in ixs and p not in finished] if p != nullrev and p in ixs and p not in finished]
assert len(sorted) == len(ixs) assert len(sorted) == len(ixs)
return sorted return sorted