This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7248

repoview: avoid wrapping changelog if there's nothing to filter
ClosedPublic

Authored by martinvonz on Nov 5 2019, 7:59 PM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHGc8e5b3094a1d: repoview: avoid wrapping changelog if there's nothing to filter
rHGaeb9ce57f358: repoview: avoid wrapping changelog if there's nothing to filter
Summary

This simplifies the code a bit by moving the optimizaton for no
filtered revisions to one place. I assume it also makes working with
repos without obsmarkers a little faster, but it doesn't seem
significant.

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

martinvonz created this revision.Nov 5 2019, 7:59 PM
indygreg accepted this revision.Nov 5 2019, 10:35 PM
indygreg added a subscriber: indygreg.

Nice series.

The only thing that I would consider changing is moving the class definition out of a function so it can more easily be monkeypatched. We can always construct a new type using the generic class as a base to facilitate wrapping the changelog. The code in localrepo.py for deriving a custom repo type could be used as inspiration.

This revision is now accepted and ready to land.Nov 5 2019, 10:35 PM

Revision Contents
Changeset List

PathPackages
Mmercurial/repoview.py (12 lines)

Diff 17598

mercurial/repoview.py

getattr, getattr,
setattr, setattr,
) )
from . import ( from . import (
error, error,
obsolete, obsolete,
phases, phases,
pycompat, pycompat,
revlog,
tags as tagsmod, tags as tagsmod,
util, util,
) )
from .utils import repoviewutil from .utils import repoviewutil
def hideablerevs(repo): def hideablerevs(repo):
"""Revision candidates to be hidden """Revision candidates to be hidden
return i return i
def __contains__(self, rev): def __contains__(self, rev):
"""filtered version of revlog.__contains__""" """filtered version of revlog.__contains__"""
return 0 <= rev < len(self) and rev not in self.filteredrevs return 0 <= rev < len(self) and rev not in self.filteredrevs
def __iter__(self): def __iter__(self):
"""filtered version of revlog.__iter__""" """filtered version of revlog.__iter__"""
if len(self.filteredrevs) == 0:
return revlog.revlog.__iter__(self)
def filterediter(): def filterediter():
for i in pycompat.xrange(len(self)): for i in pycompat.xrange(len(self)):
if i not in self.filteredrevs: if i not in self.filteredrevs:
yield i yield i
return filterediter() return filterediter()
def revs(self, start=0, stop=None): def revs(self, start=0, stop=None):
else: else:
offenders = filteredrevs.intersection(revs) offenders = filteredrevs.intersection(revs)
for rev in offenders: for rev in offenders:
raise error.FilteredIndexError(rev) raise error.FilteredIndexError(rev)
return revs return revs
def headrevs(self, revs=None): def headrevs(self, revs=None):
if revs is None and self.filteredrevs: if revs is None:
try: try:
return self.index.headrevsfiltered(self.filteredrevs) return self.index.headrevsfiltered(self.filteredrevs)
# AttributeError covers non-c-extension environments and # AttributeError covers non-c-extension environments and
# old c extensions without filter handling. # old c extensions without filter handling.
except AttributeError: except AttributeError:
return self._headrevs() return self._headrevs()
if self.filteredrevs:
revs = self._checknofilteredinrevs(revs) revs = self._checknofilteredinrevs(revs)
return super(filteredchangelog, self).headrevs(revs) return super(filteredchangelog, self).headrevs(revs)
def strip(self, *args, **kwargs): def strip(self, *args, **kwargs):
# XXX make something better than assert # XXX make something better than assert
# We can't expect proper strip behavior if we are filtered. # We can't expect proper strip behavior if we are filtered.
assert not self.filteredrevs assert not self.filteredrevs
super(filteredchangelog, self).strip(*args, **kwargs) super(filteredchangelog, self).strip(*args, **kwargs)
# if cl.index is not unfiindex, unfi.changelog would be # if cl.index is not unfiindex, unfi.changelog would be
# recreated, and our clcache refers to garbage object # recreated, and our clcache refers to garbage object
if cl is not None and ( if cl is not None and (
cl.index is not unfiindex or newkey != self._clcachekey cl.index is not unfiindex or newkey != self._clcachekey
): ):
cl = None cl = None
# could have been made None by the previous if # could have been made None by the previous if
if cl is None: if cl is None:
cl = wrapchangelog(unfichangelog, revs) # Only filter if there's something to filter
cl = wrapchangelog(unfichangelog, revs) if revs else unfichangelog
object.__setattr__(self, r'_clcache', cl) object.__setattr__(self, r'_clcache', cl)
object.__setattr__(self, r'_clcachekey', newkey) object.__setattr__(self, r'_clcachekey', newkey)
return cl return cl
def unfiltered(self): def unfiltered(self):
"""Return an unfiltered version of a repo""" """Return an unfiltered version of a repo"""
return self._unfilteredrepo return self._unfilteredrepo