2144     """

  2144     """

  2145     def __init__(self, data):

  2145     def __init__(self, data):

  2146         super(baseset, self).__init__(data)

  2146         super(baseset, self).__init__(data)

  2147         self._set = None

  2147         self._set = None

  2148 

  2148 

  2149     def set(self):

  2155     def set(self):

  2150         if not self._set:

  2156         if not self._set:

  2151             self._set = set(self)

  2157             self._set = set(self)

  2152         return self._set

  2158         return self._set

  2153 

  2159 

  2178     """

  2184     """

  2179     def __init__(self, subset, condition=lambda x: True):

  2185     def __init__(self, subset, condition=lambda x: True):

  2180         self._subset = subset

  2186         self._subset = subset

  2181         self._condition = condition

  2187         self._condition = condition

  2182         self._cache = {}

  2188         self._cache = {}

  2183 

  2195 

  2184     def __contains__(self, x):

  2196     def __contains__(self, x):

  2185         c = self._cache

  2197         c = self._cache

  2186         if x not in c:

  2198         if x not in c:

  2187             c[x] = x in self._subset and self._condition(x)

  2199             c[x] = x in self._subset and self._condition(x)

  2247         self._ascending = ascending

  2259         self._ascending = ascending

  2248 

  2260 

  2249     def filter(self, l):

  2261     def filter(self, l):

  2250         return orderedlazyset(self, l, ascending=self._ascending)

  2262         return orderedlazyset(self, l, ascending=self._ascending)

  2251 

  2263 

  2252     def __and__(self, x):

  2272     def __and__(self, x):

  2253         return orderedlazyset(self, lambda r: r in x,

  2273         return orderedlazyset(self, lambda r: r in x,

  2254                 ascending=self._ascending)

  2274                 ascending=self._ascending)

  2255 

  2275 

  2256     def __sub__(self, x):

  2276     def __sub__(self, x):

  2257         return orderedlazyset(self, lambda r: r not in x,

  2277         return orderedlazyset(self, lambda r: r not in x,

  2258                 ascending=self._ascending)

  2278                 ascending=self._ascending)

  2259 

  2283 

  2260 class generatorset(object):

  2284 class generatorset(object):

  2261     """Wrapper structure for generators that provides lazy membership and can

  2285     """Wrapper structure for generators that provides lazy membership and can

  2262     be iterated more than once.

  2286     be iterated more than once.

  2263     When asked for membership it generates values until either it finds the

  2287     When asked for membership it generates values until either it finds the

  2339         if end is not None:

  2363         if end is not None:

  2340             self._end = end

  2364             self._end = end

  2341         else:

  2365         else:

  2342             self._end = len(repo)

  2366             self._end = len(repo)

  2343         self._hiddenrevs = repo.changelog.filteredrevs

  2367         self._hiddenrevs = repo.changelog.filteredrevs

  2344 

  2376 

  2345     def _contained(self, rev):

  2377     def _contained(self, rev):

  2346         return (rev <= self._start and rev > self._end) or (rev >= self._start

  2378         return (rev <= self._start and rev > self._end) or (rev >= self._start

  2347                 and rev < self._end)

  2379                 and rev < self._end)

  2348 

  2380