mercurial/phases.py
changeset 35330 0c1aff6d73a7
parent 35309 d13526333835
child 35441 98cc121099fe
equal deleted inserted replaced
35329:169d66db5920 35330:0c1aff6d73a7
   206             self._phasemaxrev = nullrev
   206             self._phasemaxrev = nullrev
   207             self._phasesets = None
   207             self._phasesets = None
   208             self.filterunknown(repo)
   208             self.filterunknown(repo)
   209             self.opener = repo.svfs
   209             self.opener = repo.svfs
   210 
   210 
   211     def getrevset(self, repo, phases):
   211     def getrevset(self, repo, phases, subset=None):
   212         """return a smartset for the given phases"""
   212         """return a smartset for the given phases"""
   213         self.loadphaserevs(repo) # ensure phase's sets are loaded
   213         self.loadphaserevs(repo) # ensure phase's sets are loaded
   214         phases = set(phases)
   214         phases = set(phases)
   215         if public not in phases:
   215         if public not in phases:
   216             # fast path: _phasesets contains the interesting sets,
   216             # fast path: _phasesets contains the interesting sets,
   220                 revs = self._phasesets[p]
   220                 revs = self._phasesets[p]
   221             else:
   221             else:
   222                 revs = set.union(*[self._phasesets[p] for p in phases])
   222                 revs = set.union(*[self._phasesets[p] for p in phases])
   223             if repo.changelog.filteredrevs:
   223             if repo.changelog.filteredrevs:
   224                 revs = revs - repo.changelog.filteredrevs
   224                 revs = revs - repo.changelog.filteredrevs
   225             return smartset.baseset(revs)
   225             if subset is None:
       
   226                 return smartset.baseset(revs)
       
   227             else:
       
   228                 return subset & smartset.baseset(revs)
   226         else:
   229         else:
   227             phases = set(allphases).difference(phases)
   230             phases = set(allphases).difference(phases)
   228             if not phases:
   231             if not phases:
   229                 return smartset.fullreposet(repo)
   232                 return smartset.fullreposet(repo)
   230             if len(phases) == 1:
   233             if len(phases) == 1:
   231                 [p] = phases
   234                 [p] = phases
   232                 revs = self._phasesets[p]
   235                 revs = self._phasesets[p]
   233             else:
   236             else:
   234                 revs = set.union(*[self._phasesets[p] for p in phases])
   237                 revs = set.union(*[self._phasesets[p] for p in phases])
       
   238             if subset is None:
       
   239                 subset = smartset.fullreposet(repo)
   235             if not revs:
   240             if not revs:
   236                 return smartset.fullreposet(repo)
   241                 return subset
   237             return smartset.fullreposet(repo).filter(lambda r: r not in revs)
   242             return subset.filter(lambda r: r not in revs)
   238 
   243 
   239     def copy(self):
   244     def copy(self):
   240         # Shallow copy meant to ensure isolation in
   245         # Shallow copy meant to ensure isolation in
   241         # advance/retractboundary(), nothing more.
   246         # advance/retractboundary(), nothing more.
   242         ph = self.__class__(None, None, _load=False)
   247         ph = self.__class__(None, None, _load=False)