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
Lint Skipped
Unit
Unit Tests Skipped

Revision Contents
Changeset List

PathPackages
Mmercurial/dagop.py (13 lines)
Mmercurial/dagutil.py (21 lines)

Diff 10422

mercurial/dagop.py

def headrevs(revs, parentsfn): def headrevs(revs, parentsfn):
"""Resolve the set of heads from a set of revisions. """Resolve the set of heads from a set of revisions.
Receives an iterable of revision numbers and a callbable that receives a Receives an iterable of revision numbers and a callbable that receives a
revision number and returns an iterable of parent revision numbers, possibly revision number and returns an iterable of parent revision numbers, possibly
including nullrev. including nullrev.
Returns a set of revision numbers that are DAG heads within the passed subset. Returns a set of revision numbers that are DAG heads within the passed
subset.
``nullrev`` is never included in the returned set, even if it is provided in
the input set.
""" """
headrevs = set() headrevs = set(revs)
for rev in revs: for rev in revs:
for prev in parentsfn(rev): for prev in parentsfn(rev):
if prev != node.nullrev:
headrevs.discard(prev) headrevs.discard(prev)
headrevs.discard(node.nullrev)
return headrevs return headrevs

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