author | Augie Fackler <augie@google.com> |
Wed, 12 Sep 2018 11:38:46 -0400 | |
changeset 39577 | cb1329738d64 |
parent 38783 | e7aa113b14f7 |
child 40233 | 6309128ff61f |
permissions | -rw-r--r-- |
30881
1be65deb3d54
smartset: move set classes and related functions from revset module (API)
Yuya Nishihara <yuya@tcha.org>
parents:
30850
diff
changeset
|
1 |
# smartset.py - data structure for revision set |
11275 | 2 |
# |
3 |
# Copyright 2010 Matt Mackall <mpm@selenic.com> |
|
4 |
# |
|
5 |
# This software may be used and distributed according to the terms of the |
|
6 |
# GNU General Public License version 2 or any later version. |
|
7 |
||
25971
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
8 |
from __future__ import absolute_import |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
9 |
|
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
10 |
from . import ( |
35901
f0827211eb1f
py3: build repr() of smartset as bytes then convert to str
Yuya Nishihara <yuya@tcha.org>
parents:
35838
diff
changeset
|
11 |
encoding, |
32819
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
12 |
error, |
35901
f0827211eb1f
py3: build repr() of smartset as bytes then convert to str
Yuya Nishihara <yuya@tcha.org>
parents:
35838
diff
changeset
|
13 |
pycompat, |
25971
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
14 |
util, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
15 |
) |
38576
a3130208db1c
stringutil: move _formatsetrepr() from smartset
Yuya Nishihara <yuya@tcha.org>
parents:
38575
diff
changeset
|
16 |
from .utils import ( |
a3130208db1c
stringutil: move _formatsetrepr() from smartset
Yuya Nishihara <yuya@tcha.org>
parents:
38575
diff
changeset
|
17 |
stringutil, |
a3130208db1c
stringutil: move _formatsetrepr() from smartset
Yuya Nishihara <yuya@tcha.org>
parents:
38575
diff
changeset
|
18 |
) |
35901
f0827211eb1f
py3: build repr() of smartset as bytes then convert to str
Yuya Nishihara <yuya@tcha.org>
parents:
35838
diff
changeset
|
19 |
|
f0827211eb1f
py3: build repr() of smartset as bytes then convert to str
Yuya Nishihara <yuya@tcha.org>
parents:
35838
diff
changeset
|
20 |
def _typename(o): |
f0827211eb1f
py3: build repr() of smartset as bytes then convert to str
Yuya Nishihara <yuya@tcha.org>
parents:
35838
diff
changeset
|
21 |
return pycompat.sysbytes(type(o).__name__).lstrip('_') |
28423
0d79d91ba7e3
revset: add extra data to filteredset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28395
diff
changeset
|
22 |
|
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
23 |
class abstractsmartset(object): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
24 |
|
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
25 |
def __nonzero__(self): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
26 |
"""True if the smartset is not empty""" |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
27 |
raise NotImplementedError() |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
28 |
|
31476
413b44003462
py3: add __bool__ to every class defining __nonzero__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31446
diff
changeset
|
29 |
__bool__ = __nonzero__ |
413b44003462
py3: add __bool__ to every class defining __nonzero__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31446
diff
changeset
|
30 |
|
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
31 |
def __contains__(self, rev): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
32 |
"""provide fast membership testing""" |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
33 |
raise NotImplementedError() |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
34 |
|
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
35 |
def __iter__(self): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
36 |
"""iterate the set in the order it is supposed to be iterated""" |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
37 |
raise NotImplementedError() |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
38 |
|
22716
6877ba8d85ff
abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22715
diff
changeset
|
39 |
# Attributes containing a function to perform a fast iteration in a given |
6877ba8d85ff
abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22715
diff
changeset
|
40 |
# direction. A smartset can have none, one, or both defined. |
6877ba8d85ff
abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22715
diff
changeset
|
41 |
# |
6877ba8d85ff
abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22715
diff
changeset
|
42 |
# Default value is None instead of a function returning None to avoid |
6877ba8d85ff
abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22715
diff
changeset
|
43 |
# initializing an iterator just for testing if a fast method exists. |
6877ba8d85ff
abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22715
diff
changeset
|
44 |
fastasc = None |
6877ba8d85ff
abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22715
diff
changeset
|
45 |
fastdesc = None |
6877ba8d85ff
abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22715
diff
changeset
|
46 |
|
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
47 |
def isascending(self): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
48 |
"""True if the set will iterate in ascending order""" |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
49 |
raise NotImplementedError() |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
50 |
|
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
51 |
def isdescending(self): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
52 |
"""True if the set will iterate in descending order""" |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
53 |
raise NotImplementedError() |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
54 |
|
29346
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
55 |
def istopo(self): |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
56 |
"""True if the set will iterate in topographical order""" |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
57 |
raise NotImplementedError() |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
58 |
|
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
59 |
def min(self): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
60 |
"""return the minimum element in the set""" |
30227
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
61 |
if self.fastasc is None: |
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
62 |
v = min(self) |
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
63 |
else: |
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
64 |
for v in self.fastasc(): |
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
65 |
break |
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
66 |
else: |
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
67 |
raise ValueError('arg is an empty sequence') |
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
68 |
self.min = lambda: v |
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
69 |
return v |
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
70 |
|
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
71 |
def max(self): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
72 |
"""return the maximum element in the set""" |
30227
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
73 |
if self.fastdesc is None: |
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
74 |
return max(self) |
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
75 |
else: |
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
76 |
for v in self.fastdesc(): |
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
77 |
break |
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
78 |
else: |
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
79 |
raise ValueError('arg is an empty sequence') |
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
80 |
self.max = lambda: v |
5ee944b9c750
revset: don't cache abstractsmartset min/max invocations infinitely
Mads Kiilerich <madski@unity3d.com>
parents:
30205
diff
changeset
|
81 |
return v |
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
82 |
|
22808
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
83 |
def first(self): |
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
84 |
"""return the first element in the set (user iteration perspective) |
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
85 |
|
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
86 |
Return None if the set is empty""" |
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
87 |
raise NotImplementedError() |
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
88 |
|
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
89 |
def last(self): |
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
90 |
"""return the last element in the set (user iteration perspective) |
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
91 |
|
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
92 |
Return None if the set is empty""" |
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
93 |
raise NotImplementedError() |
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
94 |
|
22995
2587631c5f8a
revset: make __len__ part of the offical API
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22944
diff
changeset
|
95 |
def __len__(self): |
2587631c5f8a
revset: make __len__ part of the offical API
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22944
diff
changeset
|
96 |
"""return the length of the smartsets |
2587631c5f8a
revset: make __len__ part of the offical API
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22944
diff
changeset
|
97 |
|
2587631c5f8a
revset: make __len__ part of the offical API
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22944
diff
changeset
|
98 |
This can be expensive on smartset that could be lazy otherwise.""" |
2587631c5f8a
revset: make __len__ part of the offical API
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22944
diff
changeset
|
99 |
raise NotImplementedError() |
2587631c5f8a
revset: make __len__ part of the offical API
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22944
diff
changeset
|
100 |
|
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
101 |
def reverse(self): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
102 |
"""reverse the expected iteration order""" |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
103 |
raise NotImplementedError() |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
104 |
|
33072
6d767d62b25e
smartset: fix default value of abstractsmartset.sort()
Yuya Nishihara <yuya@tcha.org>
parents:
32977
diff
changeset
|
105 |
def sort(self, reverse=False): |
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
106 |
"""get the set to iterate in an ascending or descending order""" |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
107 |
raise NotImplementedError() |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
108 |
|
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
109 |
def __and__(self, other): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
110 |
"""Returns a new object with the intersection of the two collections. |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
111 |
|
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
112 |
This is part of the mandatory API for smartset.""" |
24459
7d369fae098e
revset: optimize "x & fullreposet" case
Yuya Nishihara <yuya@tcha.org>
parents:
24458
diff
changeset
|
113 |
if isinstance(other, fullreposet): |
7d369fae098e
revset: optimize "x & fullreposet" case
Yuya Nishihara <yuya@tcha.org>
parents:
24458
diff
changeset
|
114 |
return self |
28423
0d79d91ba7e3
revset: add extra data to filteredset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28395
diff
changeset
|
115 |
return self.filter(other.__contains__, condrepr=other, cache=False) |
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
116 |
|
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
117 |
def __add__(self, other): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
118 |
"""Returns a new object with the union of the two collections. |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
119 |
|
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
120 |
This is part of the mandatory API for smartset.""" |
22861
546fa6576815
revset: restore order of `or` operation as in Mercurial 2.9
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22860
diff
changeset
|
121 |
return addset(self, other) |
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
122 |
|
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
123 |
def __sub__(self, other): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
124 |
"""Returns a new object with the substraction of the two collections. |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
125 |
|
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
126 |
This is part of the mandatory API for smartset.""" |
22730
aeacc2055f0d
abstractsmartset: add default implementation for __sub__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22729
diff
changeset
|
127 |
c = other.__contains__ |
28423
0d79d91ba7e3
revset: add extra data to filteredset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28395
diff
changeset
|
128 |
return self.filter(lambda r: not c(r), condrepr=('<not %r>', other), |
0d79d91ba7e3
revset: add extra data to filteredset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28395
diff
changeset
|
129 |
cache=False) |
0d79d91ba7e3
revset: add extra data to filteredset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28395
diff
changeset
|
130 |
|
0d79d91ba7e3
revset: add extra data to filteredset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28395
diff
changeset
|
131 |
def filter(self, condition, condrepr=None, cache=True): |
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
132 |
"""Returns this smartset filtered by condition as a new smartset. |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
133 |
|
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
134 |
`condition` is a callable which takes a revision number and returns a |
28423
0d79d91ba7e3
revset: add extra data to filteredset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28395
diff
changeset
|
135 |
boolean. Optional `condrepr` provides a printable representation of |
0d79d91ba7e3
revset: add extra data to filteredset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28395
diff
changeset
|
136 |
the given `condition`. |
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
137 |
|
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
138 |
This is part of the mandatory API for smartset.""" |
22864
96b6b3d78697
revset: cache most conditions used in `filter`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22863
diff
changeset
|
139 |
# builtin cannot be cached. but do not needs to |
96b6b3d78697
revset: cache most conditions used in `filter`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22863
diff
changeset
|
140 |
if cache and util.safehasattr(condition, 'func_code'): |
96b6b3d78697
revset: cache most conditions used in `filter`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22863
diff
changeset
|
141 |
condition = util.cachefunc(condition) |
28423
0d79d91ba7e3
revset: add extra data to filteredset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28395
diff
changeset
|
142 |
return filteredset(self, condition, condrepr) |
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
143 |
|
32819
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
144 |
def slice(self, start, stop): |
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
145 |
"""Return new smartset that contains selected elements from this set""" |
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
146 |
if start < 0 or stop < 0: |
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
147 |
raise error.ProgrammingError('negative index not allowed') |
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
148 |
return self._slice(start, stop) |
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
149 |
|
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
150 |
def _slice(self, start, stop): |
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
151 |
# sub classes may override this. start and stop must not be negative, |
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
152 |
# but start > stop is allowed, which should be an empty set. |
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
153 |
ys = [] |
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
154 |
it = iter(self) |
38783
e7aa113b14f7
global: use pycompat.xrange()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38576
diff
changeset
|
155 |
for x in pycompat.xrange(start): |
32819
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
156 |
y = next(it, None) |
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
157 |
if y is None: |
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
158 |
break |
38783
e7aa113b14f7
global: use pycompat.xrange()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38576
diff
changeset
|
159 |
for x in pycompat.xrange(stop - start): |
32819
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
160 |
y = next(it, None) |
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
161 |
if y is None: |
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
162 |
break |
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
163 |
ys.append(y) |
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
164 |
return baseset(ys, datarepr=('slice=%d:%d %r', start, stop, self)) |
4710cc4dac99
smartset: extract method to slice abstractsmartset
Yuya Nishihara <yuya@tcha.org>
parents:
32818
diff
changeset
|
165 |
|
22825
0e8bb81b58b9
baseset: stop inheriting from built-in list class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22817
diff
changeset
|
166 |
class baseset(abstractsmartset): |
20416
e72bcc245ecb
revset: added docstring to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20393
diff
changeset
|
167 |
"""Basic data structure that represents a revset and contains the basic |
e72bcc245ecb
revset: added docstring to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20393
diff
changeset
|
168 |
operation that it should be able to perform. |
20727
1e59f760d850
revset: added comments to all methods needed to duck-type from baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20726
diff
changeset
|
169 |
|
1e59f760d850
revset: added comments to all methods needed to duck-type from baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20726
diff
changeset
|
170 |
Every method in this class should be implemented by any smartset class. |
31019 | 171 |
|
172 |
This class could be constructed by an (unordered) set, or an (ordered) |
|
173 |
list-like object. If a set is provided, it'll be sorted lazily. |
|
174 |
||
175 |
>>> x = [4, 0, 7, 6] |
|
176 |
>>> y = [5, 6, 7, 3] |
|
177 |
||
178 |
Construct by a set: |
|
179 |
>>> xs = baseset(set(x)) |
|
180 |
>>> ys = baseset(set(y)) |
|
181 |
>>> [list(i) for i in [xs + ys, xs & ys, xs - ys]] |
|
182 |
[[0, 4, 6, 7, 3, 5], [6, 7], [0, 4]] |
|
183 |
>>> [type(i).__name__ for i in [xs + ys, xs & ys, xs - ys]] |
|
31020
2d1bf84046f6
smartset: use native set operations as fast paths
Jun Wu <quark@fb.com>
parents:
31019
diff
changeset
|
184 |
['addset', 'baseset', 'baseset'] |
31019 | 185 |
|
186 |
Construct by a list-like: |
|
187 |
>>> xs = baseset(x) |
|
188 |
>>> ys = baseset(i for i in y) |
|
189 |
>>> [list(i) for i in [xs + ys, xs & ys, xs - ys]] |
|
190 |
[[4, 0, 7, 6, 5, 3], [7, 6], [4, 0]] |
|
191 |
>>> [type(i).__name__ for i in [xs + ys, xs & ys, xs - ys]] |
|
192 |
['addset', 'filteredset', 'filteredset'] |
|
193 |
||
194 |
Populate "_set" fields in the lists so set optimization may be used: |
|
195 |
>>> [1 in xs, 3 in ys] |
|
196 |
[False, True] |
|
197 |
||
198 |
Without sort(), results won't be changed: |
|
199 |
>>> [list(i) for i in [xs + ys, xs & ys, xs - ys]] |
|
200 |
[[4, 0, 7, 6, 5, 3], [7, 6], [4, 0]] |
|
201 |
>>> [type(i).__name__ for i in [xs + ys, xs & ys, xs - ys]] |
|
202 |
['addset', 'filteredset', 'filteredset'] |
|
203 |
||
31020
2d1bf84046f6
smartset: use native set operations as fast paths
Jun Wu <quark@fb.com>
parents:
31019
diff
changeset
|
204 |
With sort(), set optimization could be used: |
31019 | 205 |
>>> xs.sort(reverse=True) |
206 |
>>> [list(i) for i in [xs + ys, xs & ys, xs - ys]] |
|
207 |
[[7, 6, 4, 0, 5, 3], [7, 6], [4, 0]] |
|
208 |
>>> [type(i).__name__ for i in [xs + ys, xs & ys, xs - ys]] |
|
31020
2d1bf84046f6
smartset: use native set operations as fast paths
Jun Wu <quark@fb.com>
parents:
31019
diff
changeset
|
209 |
['addset', 'baseset', 'baseset'] |
31019 | 210 |
|
211 |
>>> ys.sort() |
|
212 |
>>> [list(i) for i in [xs + ys, xs & ys, xs - ys]] |
|
213 |
[[7, 6, 4, 0, 3, 5], [7, 6], [4, 0]] |
|
214 |
>>> [type(i).__name__ for i in [xs + ys, xs & ys, xs - ys]] |
|
31020
2d1bf84046f6
smartset: use native set operations as fast paths
Jun Wu <quark@fb.com>
parents:
31019
diff
changeset
|
215 |
['addset', 'baseset', 'baseset'] |
31066
c962bb6af909
smartset: preserve istopo for baseset operations
Jun Wu <quark@fb.com>
parents:
31020
diff
changeset
|
216 |
|
c962bb6af909
smartset: preserve istopo for baseset operations
Jun Wu <quark@fb.com>
parents:
31020
diff
changeset
|
217 |
istopo is preserved across set operations |
c962bb6af909
smartset: preserve istopo for baseset operations
Jun Wu <quark@fb.com>
parents:
31020
diff
changeset
|
218 |
>>> xs = baseset(set(x), istopo=True) |
c962bb6af909
smartset: preserve istopo for baseset operations
Jun Wu <quark@fb.com>
parents:
31020
diff
changeset
|
219 |
>>> rs = xs & ys |
c962bb6af909
smartset: preserve istopo for baseset operations
Jun Wu <quark@fb.com>
parents:
31020
diff
changeset
|
220 |
>>> type(rs).__name__ |
c962bb6af909
smartset: preserve istopo for baseset operations
Jun Wu <quark@fb.com>
parents:
31020
diff
changeset
|
221 |
'baseset' |
c962bb6af909
smartset: preserve istopo for baseset operations
Jun Wu <quark@fb.com>
parents:
31020
diff
changeset
|
222 |
>>> rs._istopo |
c962bb6af909
smartset: preserve istopo for baseset operations
Jun Wu <quark@fb.com>
parents:
31020
diff
changeset
|
223 |
True |
20416
e72bcc245ecb
revset: added docstring to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20393
diff
changeset
|
224 |
""" |
29346
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
225 |
def __init__(self, data=(), datarepr=None, istopo=False): |
28425
02d7faaf455c
revset: stub to add extra data to baseset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28424
diff
changeset
|
226 |
""" |
02d7faaf455c
revset: stub to add extra data to baseset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28424
diff
changeset
|
227 |
datarepr: a tuple of (format, obj, ...), a function or an object that |
02d7faaf455c
revset: stub to add extra data to baseset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28424
diff
changeset
|
228 |
provides a printable representation of the given data. |
02d7faaf455c
revset: stub to add extra data to baseset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28424
diff
changeset
|
229 |
""" |
28786
69c6e9623bdc
revset: force ascending order for baseset initialized from a set
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
28785
diff
changeset
|
230 |
self._ascending = None |
29346
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
231 |
self._istopo = istopo |
31127
90fb0193f187
smartset: reorder initialization of baseset in more intuitive way
Yuya Nishihara <yuya@tcha.org>
parents:
31066
diff
changeset
|
232 |
if isinstance(data, set): |
90fb0193f187
smartset: reorder initialization of baseset in more intuitive way
Yuya Nishihara <yuya@tcha.org>
parents:
31066
diff
changeset
|
233 |
# converting set to list has a cost, do it lazily |
90fb0193f187
smartset: reorder initialization of baseset in more intuitive way
Yuya Nishihara <yuya@tcha.org>
parents:
31066
diff
changeset
|
234 |
self._set = data |
90fb0193f187
smartset: reorder initialization of baseset in more intuitive way
Yuya Nishihara <yuya@tcha.org>
parents:
31066
diff
changeset
|
235 |
# set has no order we pick one for stability purpose |
90fb0193f187
smartset: reorder initialization of baseset in more intuitive way
Yuya Nishihara <yuya@tcha.org>
parents:
31066
diff
changeset
|
236 |
self._ascending = True |
90fb0193f187
smartset: reorder initialization of baseset in more intuitive way
Yuya Nishihara <yuya@tcha.org>
parents:
31066
diff
changeset
|
237 |
else: |
90fb0193f187
smartset: reorder initialization of baseset in more intuitive way
Yuya Nishihara <yuya@tcha.org>
parents:
31066
diff
changeset
|
238 |
if not isinstance(data, list): |
31015
1076f7eba964
smartset: convert set to list lazily
Jun Wu <quark@fb.com>
parents:
30881
diff
changeset
|
239 |
data = list(data) |
1076f7eba964
smartset: convert set to list lazily
Jun Wu <quark@fb.com>
parents:
30881
diff
changeset
|
240 |
self._list = data |
28425
02d7faaf455c
revset: stub to add extra data to baseset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28424
diff
changeset
|
241 |
self._datarepr = datarepr |
20365
bc770ee6a351
revset: implemented set caching for revset evaluation
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20364
diff
changeset
|
242 |
|
22826
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
243 |
@util.propertycache |
22879
efe5062145c1
baseset: make `_set` a property cache
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22877
diff
changeset
|
244 |
def _set(self): |
efe5062145c1
baseset: make `_set` a property cache
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22877
diff
changeset
|
245 |
return set(self._list) |
efe5062145c1
baseset: make `_set` a property cache
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22877
diff
changeset
|
246 |
|
efe5062145c1
baseset: make `_set` a property cache
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22877
diff
changeset
|
247 |
@util.propertycache |
22826
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
248 |
def _asclist(self): |
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
249 |
asclist = self._list[:] |
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
250 |
asclist.sort() |
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
251 |
return asclist |
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
252 |
|
31015
1076f7eba964
smartset: convert set to list lazily
Jun Wu <quark@fb.com>
parents:
30881
diff
changeset
|
253 |
@util.propertycache |
1076f7eba964
smartset: convert set to list lazily
Jun Wu <quark@fb.com>
parents:
30881
diff
changeset
|
254 |
def _list(self): |
1076f7eba964
smartset: convert set to list lazily
Jun Wu <quark@fb.com>
parents:
30881
diff
changeset
|
255 |
# _list is only lazily constructed if we have _set |
32148
2cfdf5241096
py3: use raw strings while accessing class.__dict__
Pulkit Goyal <7895pulkit@gmail.com>
parents:
31476
diff
changeset
|
256 |
assert r'_set' in self.__dict__ |
31015
1076f7eba964
smartset: convert set to list lazily
Jun Wu <quark@fb.com>
parents:
30881
diff
changeset
|
257 |
return list(self._set) |
1076f7eba964
smartset: convert set to list lazily
Jun Wu <quark@fb.com>
parents:
30881
diff
changeset
|
258 |
|
22827
c1107cb21df2
baseset: prepare lazy ordering in __iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22826
diff
changeset
|
259 |
def __iter__(self): |
c1107cb21df2
baseset: prepare lazy ordering in __iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22826
diff
changeset
|
260 |
if self._ascending is None: |
c1107cb21df2
baseset: prepare lazy ordering in __iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22826
diff
changeset
|
261 |
return iter(self._list) |
c1107cb21df2
baseset: prepare lazy ordering in __iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22826
diff
changeset
|
262 |
elif self._ascending: |
c1107cb21df2
baseset: prepare lazy ordering in __iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22826
diff
changeset
|
263 |
return iter(self._asclist) |
c1107cb21df2
baseset: prepare lazy ordering in __iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22826
diff
changeset
|
264 |
else: |
c1107cb21df2
baseset: prepare lazy ordering in __iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22826
diff
changeset
|
265 |
return reversed(self._asclist) |
c1107cb21df2
baseset: prepare lazy ordering in __iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22826
diff
changeset
|
266 |
|
22826
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
267 |
def fastasc(self): |
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
268 |
return iter(self._asclist) |
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
269 |
|
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
270 |
def fastdesc(self): |
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
271 |
return reversed(self._asclist) |
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
272 |
|
22503
300e07582e9b
revset: add an optimised baseset.__contains__ (issue4371)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22105
diff
changeset
|
273 |
@util.propertycache |
300e07582e9b
revset: add an optimised baseset.__contains__ (issue4371)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22105
diff
changeset
|
274 |
def __contains__(self): |
22880
5b635b44af14
baseset: access `_set` directly for containment check
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22879
diff
changeset
|
275 |
return self._set.__contains__ |
22503
300e07582e9b
revset: add an optimised baseset.__contains__ (issue4371)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22105
diff
changeset
|
276 |
|
22691
d8a08b68f754
revset: add a `__nonzero__` to baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22690
diff
changeset
|
277 |
def __nonzero__(self): |
31015
1076f7eba964
smartset: convert set to list lazily
Jun Wu <quark@fb.com>
parents:
30881
diff
changeset
|
278 |
return bool(len(self)) |
22825
0e8bb81b58b9
baseset: stop inheriting from built-in list class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22817
diff
changeset
|
279 |
|
31476
413b44003462
py3: add __bool__ to every class defining __nonzero__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31446
diff
changeset
|
280 |
__bool__ = __nonzero__ |
413b44003462
py3: add __bool__ to every class defining __nonzero__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31446
diff
changeset
|
281 |
|
22825
0e8bb81b58b9
baseset: stop inheriting from built-in list class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22817
diff
changeset
|
282 |
def sort(self, reverse=False): |
22829
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
283 |
self._ascending = not bool(reverse) |
29346
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
284 |
self._istopo = False |
22825
0e8bb81b58b9
baseset: stop inheriting from built-in list class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22817
diff
changeset
|
285 |
|
0e8bb81b58b9
baseset: stop inheriting from built-in list class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22817
diff
changeset
|
286 |
def reverse(self): |
22829
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
287 |
if self._ascending is None: |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
288 |
self._list.reverse() |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
289 |
else: |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
290 |
self._ascending = not self._ascending |
29346
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
291 |
self._istopo = False |
22825
0e8bb81b58b9
baseset: stop inheriting from built-in list class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22817
diff
changeset
|
292 |
|
0e8bb81b58b9
baseset: stop inheriting from built-in list class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22817
diff
changeset
|
293 |
def __len__(self): |
35838
f484b9d95c23
smartset: use native string when peeking in __dict__
Augie Fackler <augie@google.com>
parents:
35501
diff
changeset
|
294 |
if r'_list' in self.__dict__: |
31015
1076f7eba964
smartset: convert set to list lazily
Jun Wu <quark@fb.com>
parents:
30881
diff
changeset
|
295 |
return len(self._list) |
1076f7eba964
smartset: convert set to list lazily
Jun Wu <quark@fb.com>
parents:
30881
diff
changeset
|
296 |
else: |
1076f7eba964
smartset: convert set to list lazily
Jun Wu <quark@fb.com>
parents:
30881
diff
changeset
|
297 |
return len(self._set) |
22691
d8a08b68f754
revset: add a `__nonzero__` to baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22690
diff
changeset
|
298 |
|
20725
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
299 |
def isascending(self): |
20727
1e59f760d850
revset: added comments to all methods needed to duck-type from baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20726
diff
changeset
|
300 |
"""Returns True if the collection is ascending order, False if not. |
1e59f760d850
revset: added comments to all methods needed to duck-type from baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20726
diff
changeset
|
301 |
|
1e59f760d850
revset: added comments to all methods needed to duck-type from baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20726
diff
changeset
|
302 |
This is part of the mandatory API for smartset.""" |
22863
a1a02b516cca
baseset: empty or one-element sets are ascending and descending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22862
diff
changeset
|
303 |
if len(self) <= 1: |
a1a02b516cca
baseset: empty or one-element sets are ascending and descending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22862
diff
changeset
|
304 |
return True |
22828
966860f7a1a8
baseset: fix isascending and isdescending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22827
diff
changeset
|
305 |
return self._ascending is not None and self._ascending |
20725
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
306 |
|
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
307 |
def isdescending(self): |
20727
1e59f760d850
revset: added comments to all methods needed to duck-type from baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20726
diff
changeset
|
308 |
"""Returns True if the collection is descending order, False if not. |
1e59f760d850
revset: added comments to all methods needed to duck-type from baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20726
diff
changeset
|
309 |
|
1e59f760d850
revset: added comments to all methods needed to duck-type from baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20726
diff
changeset
|
310 |
This is part of the mandatory API for smartset.""" |
22863
a1a02b516cca
baseset: empty or one-element sets are ascending and descending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22862
diff
changeset
|
311 |
if len(self) <= 1: |
a1a02b516cca
baseset: empty or one-element sets are ascending and descending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22862
diff
changeset
|
312 |
return True |
22828
966860f7a1a8
baseset: fix isascending and isdescending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22827
diff
changeset
|
313 |
return self._ascending is not None and not self._ascending |
20725
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
314 |
|
29346
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
315 |
def istopo(self): |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
316 |
"""Is the collection is in topographical order or not. |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
317 |
|
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
318 |
This is part of the mandatory API for smartset.""" |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
319 |
if len(self) <= 1: |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
320 |
return True |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
321 |
return self._istopo |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
322 |
|
22812
fcd12b310148
baseset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22811
diff
changeset
|
323 |
def first(self): |
fcd12b310148
baseset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22811
diff
changeset
|
324 |
if self: |
22829
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
325 |
if self._ascending is None: |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
326 |
return self._list[0] |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
327 |
elif self._ascending: |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
328 |
return self._asclist[0] |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
329 |
else: |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
330 |
return self._asclist[-1] |
22812
fcd12b310148
baseset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22811
diff
changeset
|
331 |
return None |
fcd12b310148
baseset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22811
diff
changeset
|
332 |
|
fcd12b310148
baseset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22811
diff
changeset
|
333 |
def last(self): |
fcd12b310148
baseset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22811
diff
changeset
|
334 |
if self: |
22829
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
335 |
if self._ascending is None: |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
336 |
return self._list[-1] |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
337 |
elif self._ascending: |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
338 |
return self._asclist[-1] |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
339 |
else: |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
340 |
return self._asclist[0] |
22812
fcd12b310148
baseset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22811
diff
changeset
|
341 |
return None |
fcd12b310148
baseset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22811
diff
changeset
|
342 |
|
31020
2d1bf84046f6
smartset: use native set operations as fast paths
Jun Wu <quark@fb.com>
parents:
31019
diff
changeset
|
343 |
def _fastsetop(self, other, op): |
2d1bf84046f6
smartset: use native set operations as fast paths
Jun Wu <quark@fb.com>
parents:
31019
diff
changeset
|
344 |
# try to use native set operations as fast paths |
34070
01c9700fbf9f
py3: fix type of attribute name in smartset.py
Yuya Nishihara <yuya@tcha.org>
parents:
33109
diff
changeset
|
345 |
if (type(other) is baseset and r'_set' in other.__dict__ and r'_set' in |
31020
2d1bf84046f6
smartset: use native set operations as fast paths
Jun Wu <quark@fb.com>
parents:
31019
diff
changeset
|
346 |
self.__dict__ and self._ascending is not None): |
31066
c962bb6af909
smartset: preserve istopo for baseset operations
Jun Wu <quark@fb.com>
parents:
31020
diff
changeset
|
347 |
s = baseset(data=getattr(self._set, op)(other._set), |
c962bb6af909
smartset: preserve istopo for baseset operations
Jun Wu <quark@fb.com>
parents:
31020
diff
changeset
|
348 |
istopo=self._istopo) |
31020
2d1bf84046f6
smartset: use native set operations as fast paths
Jun Wu <quark@fb.com>
parents:
31019
diff
changeset
|
349 |
s._ascending = self._ascending |
2d1bf84046f6
smartset: use native set operations as fast paths
Jun Wu <quark@fb.com>
parents:
31019
diff
changeset
|
350 |
else: |
2d1bf84046f6
smartset: use native set operations as fast paths
Jun Wu <quark@fb.com>
parents:
31019
diff
changeset
|
351 |
s = getattr(super(baseset, self), op)(other) |
2d1bf84046f6
smartset: use native set operations as fast paths
Jun Wu <quark@fb.com>
parents:
31019
diff
changeset
|
352 |
return s |
2d1bf84046f6
smartset: use native set operations as fast paths
Jun Wu <quark@fb.com>
parents:
31019
diff
changeset
|
353 |
|
2d1bf84046f6
smartset: use native set operations as fast paths
Jun Wu <quark@fb.com>
parents:
31019
diff
changeset
|
354 |
def __and__(self, other): |
2d1bf84046f6
smartset: use native set operations as fast paths
Jun Wu <quark@fb.com>
parents:
31019
diff
changeset
|
355 |
return self._fastsetop(other, '__and__') |
2d1bf84046f6
smartset: use native set operations as fast paths
Jun Wu <quark@fb.com>
parents:
31019
diff
changeset
|
356 |
|
2d1bf84046f6
smartset: use native set operations as fast paths
Jun Wu <quark@fb.com>
parents:
31019
diff
changeset
|
357 |
def __sub__(self, other): |
2d1bf84046f6
smartset: use native set operations as fast paths
Jun Wu <quark@fb.com>
parents:
31019
diff
changeset
|
358 |
return self._fastsetop(other, '__sub__') |
2d1bf84046f6
smartset: use native set operations as fast paths
Jun Wu <quark@fb.com>
parents:
31019
diff
changeset
|
359 |
|
32820
653d60455dbe
smartset: micro optimize baseset.slice() to use slice of list
Yuya Nishihara <yuya@tcha.org>
parents:
32819
diff
changeset
|
360 |
def _slice(self, start, stop): |
653d60455dbe
smartset: micro optimize baseset.slice() to use slice of list
Yuya Nishihara <yuya@tcha.org>
parents:
32819
diff
changeset
|
361 |
# creating new list should be generally cheaper than iterating items |
653d60455dbe
smartset: micro optimize baseset.slice() to use slice of list
Yuya Nishihara <yuya@tcha.org>
parents:
32819
diff
changeset
|
362 |
if self._ascending is None: |
653d60455dbe
smartset: micro optimize baseset.slice() to use slice of list
Yuya Nishihara <yuya@tcha.org>
parents:
32819
diff
changeset
|
363 |
return baseset(self._list[start:stop], istopo=self._istopo) |
653d60455dbe
smartset: micro optimize baseset.slice() to use slice of list
Yuya Nishihara <yuya@tcha.org>
parents:
32819
diff
changeset
|
364 |
|
653d60455dbe
smartset: micro optimize baseset.slice() to use slice of list
Yuya Nishihara <yuya@tcha.org>
parents:
32819
diff
changeset
|
365 |
data = self._asclist |
653d60455dbe
smartset: micro optimize baseset.slice() to use slice of list
Yuya Nishihara <yuya@tcha.org>
parents:
32819
diff
changeset
|
366 |
if not self._ascending: |
653d60455dbe
smartset: micro optimize baseset.slice() to use slice of list
Yuya Nishihara <yuya@tcha.org>
parents:
32819
diff
changeset
|
367 |
start, stop = max(len(data) - stop, 0), max(len(data) - start, 0) |
653d60455dbe
smartset: micro optimize baseset.slice() to use slice of list
Yuya Nishihara <yuya@tcha.org>
parents:
32819
diff
changeset
|
368 |
s = baseset(data[start:stop], istopo=self._istopo) |
653d60455dbe
smartset: micro optimize baseset.slice() to use slice of list
Yuya Nishihara <yuya@tcha.org>
parents:
32819
diff
changeset
|
369 |
s._ascending = self._ascending |
653d60455dbe
smartset: micro optimize baseset.slice() to use slice of list
Yuya Nishihara <yuya@tcha.org>
parents:
32819
diff
changeset
|
370 |
return s |
653d60455dbe
smartset: micro optimize baseset.slice() to use slice of list
Yuya Nishihara <yuya@tcha.org>
parents:
32819
diff
changeset
|
371 |
|
35901
f0827211eb1f
py3: build repr() of smartset as bytes then convert to str
Yuya Nishihara <yuya@tcha.org>
parents:
35838
diff
changeset
|
372 |
@encoding.strmethod |
24457
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
373 |
def __repr__(self): |
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
374 |
d = {None: '', False: '-', True: '+'}[self._ascending] |
38576
a3130208db1c
stringutil: move _formatsetrepr() from smartset
Yuya Nishihara <yuya@tcha.org>
parents:
38575
diff
changeset
|
375 |
s = stringutil.buildrepr(self._datarepr) |
28425
02d7faaf455c
revset: stub to add extra data to baseset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28424
diff
changeset
|
376 |
if not s: |
28785
87b89dca669d
revset: stabilize repr of baseset initialized with a set
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
28720
diff
changeset
|
377 |
l = self._list |
87b89dca669d
revset: stabilize repr of baseset initialized with a set
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
28720
diff
changeset
|
378 |
# if _list has been built from a set, it might have a different |
87b89dca669d
revset: stabilize repr of baseset initialized with a set
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
28720
diff
changeset
|
379 |
# order from one python implementation to another. |
87b89dca669d
revset: stabilize repr of baseset initialized with a set
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
28720
diff
changeset
|
380 |
# We fallback to the sorted version for a stable output. |
87b89dca669d
revset: stabilize repr of baseset initialized with a set
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
28720
diff
changeset
|
381 |
if self._ascending is not None: |
87b89dca669d
revset: stabilize repr of baseset initialized with a set
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
28720
diff
changeset
|
382 |
l = self._asclist |
36265
b44fac3a49fb
py3: factor out byterepr() which returns an asciified value on py3
Yuya Nishihara <yuya@tcha.org>
parents:
35904
diff
changeset
|
383 |
s = pycompat.byterepr(l) |
35901
f0827211eb1f
py3: build repr() of smartset as bytes then convert to str
Yuya Nishihara <yuya@tcha.org>
parents:
35838
diff
changeset
|
384 |
return '<%s%s %s>' % (_typename(self), d, s) |
24457
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
385 |
|
22726
169aa5e74b52
lazyset: rename the class to filteredset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22725
diff
changeset
|
386 |
class filteredset(abstractsmartset): |
20427
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
387 |
"""Duck type for baseset class which iterates lazily over the revisions in |
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
388 |
the subset and contains a function which tests for membership in the |
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
389 |
revset |
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
390 |
""" |
28423
0d79d91ba7e3
revset: add extra data to filteredset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28395
diff
changeset
|
391 |
def __init__(self, subset, condition=lambda x: True, condrepr=None): |
20738
33943add5d65
revset: add some documentation for lazyset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20737
diff
changeset
|
392 |
""" |
33943add5d65
revset: add some documentation for lazyset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20737
diff
changeset
|
393 |
condition: a function that decide whether a revision in the subset |
33943add5d65
revset: add some documentation for lazyset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20737
diff
changeset
|
394 |
belongs to the revset or not. |
28423
0d79d91ba7e3
revset: add extra data to filteredset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28395
diff
changeset
|
395 |
condrepr: a tuple of (format, obj, ...), a function or an object that |
0d79d91ba7e3
revset: add extra data to filteredset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28395
diff
changeset
|
396 |
provides a printable representation of the given condition. |
20738
33943add5d65
revset: add some documentation for lazyset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20737
diff
changeset
|
397 |
""" |
20427
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
398 |
self._subset = subset |
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
399 |
self._condition = condition |
28423
0d79d91ba7e3
revset: add extra data to filteredset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28395
diff
changeset
|
400 |
self._condrepr = condrepr |
20427
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
401 |
|
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
402 |
def __contains__(self, x): |
26212
0d8df1f510c6
revset: uncache filteredset.__contains__
Yuya Nishihara <yuya@tcha.org>
parents:
26143
diff
changeset
|
403 |
return x in self._subset and self._condition(x) |
20427
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
404 |
|
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
405 |
def __iter__(self): |
22719
21fda9dcd4e8
lazyset: split the iteration logic from the condition filtering logic
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22718
diff
changeset
|
406 |
return self._iterfilter(self._subset) |
21fda9dcd4e8
lazyset: split the iteration logic from the condition filtering logic
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22718
diff
changeset
|
407 |
|
21fda9dcd4e8
lazyset: split the iteration logic from the condition filtering logic
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22718
diff
changeset
|
408 |
def _iterfilter(self, it): |
20427
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
409 |
cond = self._condition |
22719
21fda9dcd4e8
lazyset: split the iteration logic from the condition filtering logic
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22718
diff
changeset
|
410 |
for x in it: |
20427
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
411 |
if cond(x): |
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
412 |
yield x |
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
413 |
|
22720
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
414 |
@property |
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
415 |
def fastasc(self): |
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
416 |
it = self._subset.fastasc |
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
417 |
if it is None: |
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
418 |
return None |
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
419 |
return lambda: self._iterfilter(it()) |
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
420 |
|
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
421 |
@property |
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
422 |
def fastdesc(self): |
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
423 |
it = self._subset.fastdesc |
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
424 |
if it is None: |
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
425 |
return None |
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
426 |
return lambda: self._iterfilter(it()) |
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
427 |
|
20552
0e99a66eb7bc
revset: added __nonzero__ method to lazyset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20540
diff
changeset
|
428 |
def __nonzero__(self): |
29304
5e32852fa4bd
revset: make filteredset.__nonzero__ respect the order of the filteredset
Kostia Balytskyi <ikostia@fb.com>
parents:
29265
diff
changeset
|
429 |
fast = None |
5e32852fa4bd
revset: make filteredset.__nonzero__ respect the order of the filteredset
Kostia Balytskyi <ikostia@fb.com>
parents:
29265
diff
changeset
|
430 |
candidates = [self.fastasc if self.isascending() else None, |
5e32852fa4bd
revset: make filteredset.__nonzero__ respect the order of the filteredset
Kostia Balytskyi <ikostia@fb.com>
parents:
29265
diff
changeset
|
431 |
self.fastdesc if self.isdescending() else None, |
5e32852fa4bd
revset: make filteredset.__nonzero__ respect the order of the filteredset
Kostia Balytskyi <ikostia@fb.com>
parents:
29265
diff
changeset
|
432 |
self.fastasc, |
5e32852fa4bd
revset: make filteredset.__nonzero__ respect the order of the filteredset
Kostia Balytskyi <ikostia@fb.com>
parents:
29265
diff
changeset
|
433 |
self.fastdesc] |
5e32852fa4bd
revset: make filteredset.__nonzero__ respect the order of the filteredset
Kostia Balytskyi <ikostia@fb.com>
parents:
29265
diff
changeset
|
434 |
for candidate in candidates: |
5e32852fa4bd
revset: make filteredset.__nonzero__ respect the order of the filteredset
Kostia Balytskyi <ikostia@fb.com>
parents:
29265
diff
changeset
|
435 |
if candidate is not None: |
5e32852fa4bd
revset: make filteredset.__nonzero__ respect the order of the filteredset
Kostia Balytskyi <ikostia@fb.com>
parents:
29265
diff
changeset
|
436 |
fast = candidate |
5e32852fa4bd
revset: make filteredset.__nonzero__ respect the order of the filteredset
Kostia Balytskyi <ikostia@fb.com>
parents:
29265
diff
changeset
|
437 |
break |
5e32852fa4bd
revset: make filteredset.__nonzero__ respect the order of the filteredset
Kostia Balytskyi <ikostia@fb.com>
parents:
29265
diff
changeset
|
438 |
|
26307
428a8747f4ee
revset: avoid implicit None testing in revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26306
diff
changeset
|
439 |
if fast is not None: |
26306
d157e1f18e3f
revset: speed up existence checks for ordered filtered sets
Durham Goode <durham@fb.com>
parents:
26305
diff
changeset
|
440 |
it = fast() |
26307
428a8747f4ee
revset: avoid implicit None testing in revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26306
diff
changeset
|
441 |
else: |
428a8747f4ee
revset: avoid implicit None testing in revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26306
diff
changeset
|
442 |
it = self |
26306
d157e1f18e3f
revset: speed up existence checks for ordered filtered sets
Durham Goode <durham@fb.com>
parents:
26305
diff
changeset
|
443 |
|
d157e1f18e3f
revset: speed up existence checks for ordered filtered sets
Durham Goode <durham@fb.com>
parents:
26305
diff
changeset
|
444 |
for r in it: |
20552
0e99a66eb7bc
revset: added __nonzero__ method to lazyset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20540
diff
changeset
|
445 |
return True |
0e99a66eb7bc
revset: added __nonzero__ method to lazyset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20540
diff
changeset
|
446 |
return False |
0e99a66eb7bc
revset: added __nonzero__ method to lazyset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20540
diff
changeset
|
447 |
|
31476
413b44003462
py3: add __bool__ to every class defining __nonzero__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31446
diff
changeset
|
448 |
__bool__ = __nonzero__ |
413b44003462
py3: add __bool__ to every class defining __nonzero__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31446
diff
changeset
|
449 |
|
20429
f5b560c60bcd
revset: added operations to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20428
diff
changeset
|
450 |
def __len__(self): |
f5b560c60bcd
revset: added operations to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20428
diff
changeset
|
451 |
# Basic implementation to be changed in future patches. |
28718
f103f985ac00
revset: prevent infinite recursion on pypy
Maciej Fijalkowski <fijall@gmail.com>
parents:
28717
diff
changeset
|
452 |
# until this gets improved, we use generator expression |
30332
318a24b52eeb
spelling: fixes of non-dictionary words
Mads Kiilerich <madski@unity3d.com>
parents:
30227
diff
changeset
|
453 |
# here, since list comprehensions are free to call __len__ again |
28718
f103f985ac00
revset: prevent infinite recursion on pypy
Maciej Fijalkowski <fijall@gmail.com>
parents:
28717
diff
changeset
|
454 |
# causing infinite recursion |
f103f985ac00
revset: prevent infinite recursion on pypy
Maciej Fijalkowski <fijall@gmail.com>
parents:
28717
diff
changeset
|
455 |
l = baseset(r for r in self) |
20429
f5b560c60bcd
revset: added operations to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20428
diff
changeset
|
456 |
return len(l) |
f5b560c60bcd
revset: added operations to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20428
diff
changeset
|
457 |
|
f5b560c60bcd
revset: added operations to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20428
diff
changeset
|
458 |
def sort(self, reverse=False): |
22862
9e5576f822cc
filteredset: drop explicit order management
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22861
diff
changeset
|
459 |
self._subset.sort(reverse=reverse) |
20429
f5b560c60bcd
revset: added operations to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20428
diff
changeset
|
460 |
|
f5b560c60bcd
revset: added operations to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20428
diff
changeset
|
461 |
def reverse(self): |
f5b560c60bcd
revset: added operations to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20428
diff
changeset
|
462 |
self._subset.reverse() |
f5b560c60bcd
revset: added operations to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20428
diff
changeset
|
463 |
|
20725
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
464 |
def isascending(self): |
22862
9e5576f822cc
filteredset: drop explicit order management
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22861
diff
changeset
|
465 |
return self._subset.isascending() |
20725
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
466 |
|
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
467 |
def isdescending(self): |
22862
9e5576f822cc
filteredset: drop explicit order management
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22861
diff
changeset
|
468 |
return self._subset.isdescending() |
20725
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
469 |
|
29346
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
470 |
def istopo(self): |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
471 |
return self._subset.istopo() |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
472 |
|
22813
5a96df266b2b
filteredset: implement `first` and `last`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22812
diff
changeset
|
473 |
def first(self): |
5a96df266b2b
filteredset: implement `first` and `last`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22812
diff
changeset
|
474 |
for x in self: |
5a96df266b2b
filteredset: implement `first` and `last`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22812
diff
changeset
|
475 |
return x |
5a96df266b2b
filteredset: implement `first` and `last`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22812
diff
changeset
|
476 |
return None |
5a96df266b2b
filteredset: implement `first` and `last`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22812
diff
changeset
|
477 |
|
5a96df266b2b
filteredset: implement `first` and `last`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22812
diff
changeset
|
478 |
def last(self): |
5a96df266b2b
filteredset: implement `first` and `last`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22812
diff
changeset
|
479 |
it = None |
25648
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
480 |
if self.isascending(): |
22862
9e5576f822cc
filteredset: drop explicit order management
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22861
diff
changeset
|
481 |
it = self.fastdesc |
25648
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
482 |
elif self.isdescending(): |
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
483 |
it = self.fastasc |
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
484 |
if it is not None: |
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
485 |
for x in it(): |
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
486 |
return x |
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
487 |
return None #empty case |
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
488 |
else: |
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
489 |
x = None |
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
490 |
for x in self: |
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
491 |
pass |
22813
5a96df266b2b
filteredset: implement `first` and `last`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22812
diff
changeset
|
492 |
return x |
5a96df266b2b
filteredset: implement `first` and `last`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22812
diff
changeset
|
493 |
|
35901
f0827211eb1f
py3: build repr() of smartset as bytes then convert to str
Yuya Nishihara <yuya@tcha.org>
parents:
35838
diff
changeset
|
494 |
@encoding.strmethod |
24457
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
495 |
def __repr__(self): |
36265
b44fac3a49fb
py3: factor out byterepr() which returns an asciified value on py3
Yuya Nishihara <yuya@tcha.org>
parents:
35904
diff
changeset
|
496 |
xs = [pycompat.byterepr(self._subset)] |
38576
a3130208db1c
stringutil: move _formatsetrepr() from smartset
Yuya Nishihara <yuya@tcha.org>
parents:
38575
diff
changeset
|
497 |
s = stringutil.buildrepr(self._condrepr) |
28423
0d79d91ba7e3
revset: add extra data to filteredset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28395
diff
changeset
|
498 |
if s: |
0d79d91ba7e3
revset: add extra data to filteredset for better inspection
Yuya Nishihara <yuya@tcha.org>
parents:
28395
diff
changeset
|
499 |
xs.append(s) |
35901
f0827211eb1f
py3: build repr() of smartset as bytes then convert to str
Yuya Nishihara <yuya@tcha.org>
parents:
35838
diff
changeset
|
500 |
return '<%s %s>' % (_typename(self), ', '.join(xs)) |
24457
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
501 |
|
25131
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
502 |
def _iterordered(ascending, iter1, iter2): |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
503 |
"""produce an ordered iteration from two iterators with the same order |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
504 |
|
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
505 |
The ascending is used to indicated the iteration direction. |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
506 |
""" |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
507 |
choice = max |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
508 |
if ascending: |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
509 |
choice = min |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
510 |
|
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
511 |
val1 = None |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
512 |
val2 = None |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
513 |
try: |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
514 |
# Consume both iterators in an ordered way until one is empty |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
515 |
while True: |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
516 |
if val1 is None: |
29216
ead25aa27a43
py3: convert to next() function
timeless <timeless@mozdev.org>
parents:
29215
diff
changeset
|
517 |
val1 = next(iter1) |
25131
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
518 |
if val2 is None: |
29216
ead25aa27a43
py3: convert to next() function
timeless <timeless@mozdev.org>
parents:
29215
diff
changeset
|
519 |
val2 = next(iter2) |
29215
f5983805574e
revset: rename variable to avoid shadowing with builtin next() function
timeless <timeless@mozdev.org>
parents:
29147
diff
changeset
|
520 |
n = choice(val1, val2) |
f5983805574e
revset: rename variable to avoid shadowing with builtin next() function
timeless <timeless@mozdev.org>
parents:
29147
diff
changeset
|
521 |
yield n |
f5983805574e
revset: rename variable to avoid shadowing with builtin next() function
timeless <timeless@mozdev.org>
parents:
29147
diff
changeset
|
522 |
if val1 == n: |
25131
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
523 |
val1 = None |
29215
f5983805574e
revset: rename variable to avoid shadowing with builtin next() function
timeless <timeless@mozdev.org>
parents:
29147
diff
changeset
|
524 |
if val2 == n: |
25131
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
525 |
val2 = None |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
526 |
except StopIteration: |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
527 |
# Flush any remaining values and consume the other one |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
528 |
it = iter2 |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
529 |
if val1 is not None: |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
530 |
yield val1 |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
531 |
it = iter1 |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
532 |
elif val2 is not None: |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
533 |
# might have been equality and both are empty |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
534 |
yield val2 |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
535 |
for val in it: |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
536 |
yield val |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
537 |
|
22793
ff6689b47e48
addset: drop the leading underscore from the class name
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22792
diff
changeset
|
538 |
class addset(abstractsmartset): |
20708
17c89e5a5627
revset: made addset a private class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20707
diff
changeset
|
539 |
"""Represent the addition of two sets |
17c89e5a5627
revset: made addset a private class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20707
diff
changeset
|
540 |
|
17c89e5a5627
revset: made addset a private class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20707
diff
changeset
|
541 |
Wrapper structure for lazily adding two structures without losing much |
20694
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
542 |
performance on the __contains__ method |
20708
17c89e5a5627
revset: made addset a private class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20707
diff
changeset
|
543 |
|
20712
c152e538b85b
revset: added ascending attribute to addset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20711
diff
changeset
|
544 |
If the ascending attribute is set, that means the two structures are |
c152e538b85b
revset: added ascending attribute to addset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20711
diff
changeset
|
545 |
ordered in either an ascending or descending way. Therefore, we can add |
21024
7731a2281cf0
spelling: fixes from spell checker
Mads Kiilerich <madski@unity3d.com>
parents:
20991
diff
changeset
|
546 |
them maintaining the order by iterating over both at the same time |
25024
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
547 |
|
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
548 |
>>> xs = baseset([0, 3, 2]) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
549 |
>>> ys = baseset([5, 2, 4]) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
550 |
|
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
551 |
>>> rs = addset(xs, ys) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
552 |
>>> bool(rs), 0 in rs, 1 in rs, 5 in rs, rs.first(), rs.last() |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
553 |
(True, True, False, True, 0, 4) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
554 |
>>> rs = addset(xs, baseset([])) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
555 |
>>> bool(rs), 0 in rs, 1 in rs, rs.first(), rs.last() |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
556 |
(True, True, False, 0, 2) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
557 |
>>> rs = addset(baseset([]), baseset([])) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
558 |
>>> bool(rs), 0 in rs, rs.first(), rs.last() |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
559 |
(False, False, None, None) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
560 |
|
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
561 |
iterate unsorted: |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
562 |
>>> rs = addset(xs, ys) |
28717
c5f212c8ad78
pypy: fix doctests for pypy optimizations
Maciej Fijalkowski <fijall@gmail.com>
parents:
28708
diff
changeset
|
563 |
>>> # (use generator because pypy could call len()) |
c5f212c8ad78
pypy: fix doctests for pypy optimizations
Maciej Fijalkowski <fijall@gmail.com>
parents:
28708
diff
changeset
|
564 |
>>> list(x for x in rs) # without _genlist |
25024
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
565 |
[0, 3, 2, 5, 4] |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
566 |
>>> assert not rs._genlist |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
567 |
>>> len(rs) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
568 |
5 |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
569 |
>>> [x for x in rs] # with _genlist |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
570 |
[0, 3, 2, 5, 4] |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
571 |
>>> assert rs._genlist |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
572 |
|
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
573 |
iterate ascending: |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
574 |
>>> rs = addset(xs, ys, ascending=True) |
28717
c5f212c8ad78
pypy: fix doctests for pypy optimizations
Maciej Fijalkowski <fijall@gmail.com>
parents:
28708
diff
changeset
|
575 |
>>> # (use generator because pypy could call len()) |
c5f212c8ad78
pypy: fix doctests for pypy optimizations
Maciej Fijalkowski <fijall@gmail.com>
parents:
28708
diff
changeset
|
576 |
>>> list(x for x in rs), list(x for x in rs.fastasc()) # without _asclist |
25024
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
577 |
([0, 2, 3, 4, 5], [0, 2, 3, 4, 5]) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
578 |
>>> assert not rs._asclist |
25115
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
579 |
>>> len(rs) |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
580 |
5 |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
581 |
>>> [x for x in rs], [x for x in rs.fastasc()] |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
582 |
([0, 2, 3, 4, 5], [0, 2, 3, 4, 5]) |
25024
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
583 |
>>> assert rs._asclist |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
584 |
|
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
585 |
iterate descending: |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
586 |
>>> rs = addset(xs, ys, ascending=False) |
28717
c5f212c8ad78
pypy: fix doctests for pypy optimizations
Maciej Fijalkowski <fijall@gmail.com>
parents:
28708
diff
changeset
|
587 |
>>> # (use generator because pypy could call len()) |
c5f212c8ad78
pypy: fix doctests for pypy optimizations
Maciej Fijalkowski <fijall@gmail.com>
parents:
28708
diff
changeset
|
588 |
>>> list(x for x in rs), list(x for x in rs.fastdesc()) # without _asclist |
25024
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
589 |
([5, 4, 3, 2, 0], [5, 4, 3, 2, 0]) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
590 |
>>> assert not rs._asclist |
25115
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
591 |
>>> len(rs) |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
592 |
5 |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
593 |
>>> [x for x in rs], [x for x in rs.fastdesc()] |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
594 |
([5, 4, 3, 2, 0], [5, 4, 3, 2, 0]) |
25024
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
595 |
>>> assert rs._asclist |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
596 |
|
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
597 |
iterate ascending without fastasc: |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
598 |
>>> rs = addset(xs, generatorset(ys), ascending=True) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
599 |
>>> assert rs.fastasc is None |
25115
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
600 |
>>> [x for x in rs] |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
601 |
[0, 2, 3, 4, 5] |
25024
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
602 |
|
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
603 |
iterate descending without fastdesc: |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
604 |
>>> rs = addset(generatorset(xs), ys, ascending=False) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
605 |
>>> assert rs.fastdesc is None |
25115
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
606 |
>>> [x for x in rs] |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
607 |
[5, 4, 3, 2, 0] |
20694
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
608 |
""" |
20712
c152e538b85b
revset: added ascending attribute to addset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20711
diff
changeset
|
609 |
def __init__(self, revs1, revs2, ascending=None): |
20694
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
610 |
self._r1 = revs1 |
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
611 |
self._r2 = revs2 |
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
612 |
self._iter = None |
20712
c152e538b85b
revset: added ascending attribute to addset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20711
diff
changeset
|
613 |
self._ascending = ascending |
20720
5f8400efca0b
revset: added cached generated list to addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20719
diff
changeset
|
614 |
self._genlist = None |
22859
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
615 |
self._asclist = None |
20720
5f8400efca0b
revset: added cached generated list to addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20719
diff
changeset
|
616 |
|
20845
bc95143446e8
_addset: add a __len__ method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20833
diff
changeset
|
617 |
def __len__(self): |
bc95143446e8
_addset: add a __len__ method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20833
diff
changeset
|
618 |
return len(self._list) |
bc95143446e8
_addset: add a __len__ method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20833
diff
changeset
|
619 |
|
22743
eccf9907b844
addset: add a __nonzero__ method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22742
diff
changeset
|
620 |
def __nonzero__(self): |
23100
ac494b087feb
revset: fix O(2^n) perf regression in addset
Durham Goode <durham@fb.com>
parents:
23078
diff
changeset
|
621 |
return bool(self._r1) or bool(self._r2) |
22743
eccf9907b844
addset: add a __nonzero__ method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22742
diff
changeset
|
622 |
|
31476
413b44003462
py3: add __bool__ to every class defining __nonzero__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31446
diff
changeset
|
623 |
__bool__ = __nonzero__ |
413b44003462
py3: add __bool__ to every class defining __nonzero__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31446
diff
changeset
|
624 |
|
20720
5f8400efca0b
revset: added cached generated list to addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20719
diff
changeset
|
625 |
@util.propertycache |
5f8400efca0b
revset: added cached generated list to addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20719
diff
changeset
|
626 |
def _list(self): |
5f8400efca0b
revset: added cached generated list to addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20719
diff
changeset
|
627 |
if not self._genlist: |
25115
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
628 |
self._genlist = baseset(iter(self)) |
20720
5f8400efca0b
revset: added cached generated list to addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20719
diff
changeset
|
629 |
return self._genlist |
20694
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
630 |
|
25115
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
631 |
def __iter__(self): |
20722
6894223ebc38
revset: changed _iterator() method on addset to work with a given order
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20721
diff
changeset
|
632 |
"""Iterate over both collections without repeating elements |
6894223ebc38
revset: changed _iterator() method on addset to work with a given order
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20721
diff
changeset
|
633 |
|
6894223ebc38
revset: changed _iterator() method on addset to work with a given order
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20721
diff
changeset
|
634 |
If the ascending attribute is not set, iterate over the first one and |
6894223ebc38
revset: changed _iterator() method on addset to work with a given order
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20721
diff
changeset
|
635 |
then over the second one checking for membership on the first one so we |
6894223ebc38
revset: changed _iterator() method on addset to work with a given order
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20721
diff
changeset
|
636 |
dont yield any duplicates. |
6894223ebc38
revset: changed _iterator() method on addset to work with a given order
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20721
diff
changeset
|
637 |
|
6894223ebc38
revset: changed _iterator() method on addset to work with a given order
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20721
diff
changeset
|
638 |
If the ascending attribute is set, iterate over both collections at the |
6894223ebc38
revset: changed _iterator() method on addset to work with a given order
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20721
diff
changeset
|
639 |
same time, yielding only one value at a time in the given order. |
6894223ebc38
revset: changed _iterator() method on addset to work with a given order
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20721
diff
changeset
|
640 |
""" |
22799
bafa371d7af3
addset: drop caching through generatorset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22798
diff
changeset
|
641 |
if self._ascending is None: |
25115
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
642 |
if self._genlist: |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
643 |
return iter(self._genlist) |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
644 |
def arbitraryordergen(): |
22799
bafa371d7af3
addset: drop caching through generatorset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22798
diff
changeset
|
645 |
for r in self._r1: |
bafa371d7af3
addset: drop caching through generatorset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22798
diff
changeset
|
646 |
yield r |
22881
057ebf7714e1
addset: drop `.set()` usage during iteration
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22880
diff
changeset
|
647 |
inr1 = self._r1.__contains__ |
22799
bafa371d7af3
addset: drop caching through generatorset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22798
diff
changeset
|
648 |
for r in self._r2: |
22881
057ebf7714e1
addset: drop `.set()` usage during iteration
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22880
diff
changeset
|
649 |
if not inr1(r): |
20694
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
650 |
yield r |
25115
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
651 |
return arbitraryordergen() |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
652 |
# try to use our own fast iterator if it exists |
22859
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
653 |
self._trysetasclist() |
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
654 |
if self._ascending: |
25130
a94ef7f517e0
revset: use fastasc/fastdesc switch consistently in addset.__iter__
Yuya Nishihara <yuya@tcha.org>
parents:
25129
diff
changeset
|
655 |
attr = 'fastasc' |
22859
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
656 |
else: |
25130
a94ef7f517e0
revset: use fastasc/fastdesc switch consistently in addset.__iter__
Yuya Nishihara <yuya@tcha.org>
parents:
25129
diff
changeset
|
657 |
attr = 'fastdesc' |
a94ef7f517e0
revset: use fastasc/fastdesc switch consistently in addset.__iter__
Yuya Nishihara <yuya@tcha.org>
parents:
25129
diff
changeset
|
658 |
it = getattr(self, attr) |
25115
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
659 |
if it is not None: |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
660 |
return it() |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
661 |
# maybe half of the component supports fast |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
662 |
# get iterator for _r1 |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
663 |
iter1 = getattr(self._r1, attr) |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
664 |
if iter1 is None: |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
665 |
# let's avoid side effect (not sure it matters) |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
666 |
iter1 = iter(sorted(self._r1, reverse=not self._ascending)) |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
667 |
else: |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
668 |
iter1 = iter1() |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
669 |
# get iterator for _r2 |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
670 |
iter2 = getattr(self._r2, attr) |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
671 |
if iter2 is None: |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
672 |
# let's avoid side effect (not sure it matters) |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
673 |
iter2 = iter(sorted(self._r2, reverse=not self._ascending)) |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
674 |
else: |
5548f558db3d
revset: fix iteration over ordered addset composed of non-ordered operands
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25105
diff
changeset
|
675 |
iter2 = iter2() |
25131
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
676 |
return _iterordered(self._ascending, iter1, iter2) |
22859
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
677 |
|
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
678 |
def _trysetasclist(self): |
23139
e53f6b72a0e4
spelling: fixes from proofreading of spell checker issues
Mads Kiilerich <madski@unity3d.com>
parents:
23127
diff
changeset
|
679 |
"""populate the _asclist attribute if possible and necessary""" |
22859
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
680 |
if self._genlist is not None and self._asclist is None: |
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
681 |
self._asclist = sorted(self._genlist) |
20694
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
682 |
|
22742
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
683 |
@property |
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
684 |
def fastasc(self): |
22859
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
685 |
self._trysetasclist() |
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
686 |
if self._asclist is not None: |
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
687 |
return self._asclist.__iter__ |
22742
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
688 |
iter1 = self._r1.fastasc |
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
689 |
iter2 = self._r2.fastasc |
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
690 |
if None in (iter1, iter2): |
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
691 |
return None |
25131
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
692 |
return lambda: _iterordered(True, iter1(), iter2()) |
22742
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
693 |
|
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
694 |
@property |
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
695 |
def fastdesc(self): |
22859
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
696 |
self._trysetasclist() |
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
697 |
if self._asclist is not None: |
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
698 |
return self._asclist.__reversed__ |
22742
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
699 |
iter1 = self._r1.fastdesc |
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
700 |
iter2 = self._r2.fastdesc |
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
701 |
if None in (iter1, iter2): |
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
702 |
return None |
25131
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
703 |
return lambda: _iterordered(False, iter1(), iter2()) |
22741
ef2c1ea8fb2c
addset: split simple and ordered iteration
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22740
diff
changeset
|
704 |
|
20694
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
705 |
def __contains__(self, x): |
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
706 |
return x in self._r1 or x in self._r2 |
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
707 |
|
20724
e9a64b3f2925
revset: added sort method in addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20723
diff
changeset
|
708 |
def sort(self, reverse=False): |
e9a64b3f2925
revset: added sort method in addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20723
diff
changeset
|
709 |
"""Sort the added set |
e9a64b3f2925
revset: added sort method in addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20723
diff
changeset
|
710 |
|
e9a64b3f2925
revset: added sort method in addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20723
diff
changeset
|
711 |
For this we use the cached list with all the generated values and if we |
e9a64b3f2925
revset: added sort method in addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20723
diff
changeset
|
712 |
know they are ascending or descending we can sort them in a smart way. |
e9a64b3f2925
revset: added sort method in addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20723
diff
changeset
|
713 |
""" |
22859
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
714 |
self._ascending = not reverse |
20724
e9a64b3f2925
revset: added sort method in addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20723
diff
changeset
|
715 |
|
20733
adf4ec7e6f60
revset: added isascending and isdescending methods to _addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20732
diff
changeset
|
716 |
def isascending(self): |
adf4ec7e6f60
revset: added isascending and isdescending methods to _addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20732
diff
changeset
|
717 |
return self._ascending is not None and self._ascending |
adf4ec7e6f60
revset: added isascending and isdescending methods to _addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20732
diff
changeset
|
718 |
|
adf4ec7e6f60
revset: added isascending and isdescending methods to _addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20732
diff
changeset
|
719 |
def isdescending(self): |
adf4ec7e6f60
revset: added isascending and isdescending methods to _addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20732
diff
changeset
|
720 |
return self._ascending is not None and not self._ascending |
adf4ec7e6f60
revset: added isascending and isdescending methods to _addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20732
diff
changeset
|
721 |
|
29346
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
722 |
def istopo(self): |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
723 |
# not worth the trouble asserting if the two sets combined are still |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
724 |
# in topographical order. Use the sort() predicate to explicitly sort |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
725 |
# again instead. |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
726 |
return False |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
727 |
|
20723
fb9852c46a42
revset: added reverse method to addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20722
diff
changeset
|
728 |
def reverse(self): |
22859
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
729 |
if self._ascending is None: |
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
730 |
self._list.reverse() |
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
731 |
else: |
20723
fb9852c46a42
revset: added reverse method to addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20722
diff
changeset
|
732 |
self._ascending = not self._ascending |
fb9852c46a42
revset: added reverse method to addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20722
diff
changeset
|
733 |
|
22810
7f97cb12782f
addset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22809
diff
changeset
|
734 |
def first(self): |
23127
7361d8244efb
addset: fix `first` and `last` on sorted addset (issue4426)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23115
diff
changeset
|
735 |
for x in self: |
7361d8244efb
addset: fix `first` and `last` on sorted addset (issue4426)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23115
diff
changeset
|
736 |
return x |
22810
7f97cb12782f
addset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22809
diff
changeset
|
737 |
return None |
7f97cb12782f
addset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22809
diff
changeset
|
738 |
|
7f97cb12782f
addset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22809
diff
changeset
|
739 |
def last(self): |
23127
7361d8244efb
addset: fix `first` and `last` on sorted addset (issue4426)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23115
diff
changeset
|
740 |
self.reverse() |
7361d8244efb
addset: fix `first` and `last` on sorted addset (issue4426)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23115
diff
changeset
|
741 |
val = self.first() |
7361d8244efb
addset: fix `first` and `last` on sorted addset (issue4426)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23115
diff
changeset
|
742 |
self.reverse() |
7361d8244efb
addset: fix `first` and `last` on sorted addset (issue4426)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23115
diff
changeset
|
743 |
return val |
22810
7f97cb12782f
addset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22809
diff
changeset
|
744 |
|
35901
f0827211eb1f
py3: build repr() of smartset as bytes then convert to str
Yuya Nishihara <yuya@tcha.org>
parents:
35838
diff
changeset
|
745 |
@encoding.strmethod |
24457
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
746 |
def __repr__(self): |
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
747 |
d = {None: '', False: '-', True: '+'}[self._ascending] |
35901
f0827211eb1f
py3: build repr() of smartset as bytes then convert to str
Yuya Nishihara <yuya@tcha.org>
parents:
35838
diff
changeset
|
748 |
return '<%s%s %r, %r>' % (_typename(self), d, self._r1, self._r2) |
24457
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
749 |
|
22795
c21342159fad
generatorset: drop the leading underscore in the class name
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22794
diff
changeset
|
750 |
class generatorset(abstractsmartset): |
20705
9cc2249a9461
revset: made generatorset a private class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20703
diff
changeset
|
751 |
"""Wrap a generator for lazy iteration |
9cc2249a9461
revset: made generatorset a private class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20703
diff
changeset
|
752 |
|
9cc2249a9461
revset: made generatorset a private class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20703
diff
changeset
|
753 |
Wrapper structure for generators that provides lazy membership and can |
20540
fa16c710a3d8
revset: added cached generated list on generatorset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20538
diff
changeset
|
754 |
be iterated more than once. |
fa16c710a3d8
revset: added cached generated list on generatorset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20538
diff
changeset
|
755 |
When asked for membership it generates values until either it finds the |
fa16c710a3d8
revset: added cached generated list on generatorset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20538
diff
changeset
|
756 |
requested one or has gone through all the elements in the generator |
33109
247bae545061
smartset: fix generatorset.last() to not return the first element (issue5609)
Yuya Nishihara <yuya@tcha.org>
parents:
33072
diff
changeset
|
757 |
|
247bae545061
smartset: fix generatorset.last() to not return the first element (issue5609)
Yuya Nishihara <yuya@tcha.org>
parents:
33072
diff
changeset
|
758 |
>>> xs = generatorset([0, 1, 4], iterasc=True) |
247bae545061
smartset: fix generatorset.last() to not return the first element (issue5609)
Yuya Nishihara <yuya@tcha.org>
parents:
33072
diff
changeset
|
759 |
>>> assert xs.last() == xs.last() |
247bae545061
smartset: fix generatorset.last() to not return the first element (issue5609)
Yuya Nishihara <yuya@tcha.org>
parents:
33072
diff
changeset
|
760 |
>>> xs.last() # cached |
247bae545061
smartset: fix generatorset.last() to not return the first element (issue5609)
Yuya Nishihara <yuya@tcha.org>
parents:
33072
diff
changeset
|
761 |
4 |
20540
fa16c710a3d8
revset: added cached generated list on generatorset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20538
diff
changeset
|
762 |
""" |
35501
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
763 |
def __new__(cls, gen, iterasc=None): |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
764 |
if iterasc is None: |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
765 |
typ = cls |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
766 |
elif iterasc: |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
767 |
typ = _generatorsetasc |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
768 |
else: |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
769 |
typ = _generatorsetdesc |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
770 |
|
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
771 |
return super(generatorset, cls).__new__(typ) |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
772 |
|
22755
f9a825b593be
generatorset: make it possible to use gen as fastasc or fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22754
diff
changeset
|
773 |
def __init__(self, gen, iterasc=None): |
20739
1b4f2399f3c4
revset: add documentation and comment for _generatorset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20738
diff
changeset
|
774 |
""" |
1b4f2399f3c4
revset: add documentation and comment for _generatorset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20738
diff
changeset
|
775 |
gen: a generator producing the values for the generatorset. |
1b4f2399f3c4
revset: add documentation and comment for _generatorset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20738
diff
changeset
|
776 |
""" |
20536
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
777 |
self._gen = gen |
22798
586d7058ea48
generatorset: get list-based fast iterations after the generator is consumed
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22797
diff
changeset
|
778 |
self._asclist = None |
20536
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
779 |
self._cache = {} |
22796
43f664bf2e1e
generatorset: stop using a base as the _genlist
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22795
diff
changeset
|
780 |
self._genlist = [] |
20703
e07b1fd30805
revset: added sort methods to generatorsets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20695
diff
changeset
|
781 |
self._finished = False |
22800
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
782 |
self._ascending = True |
20540
fa16c710a3d8
revset: added cached generated list on generatorset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20538
diff
changeset
|
783 |
|
22739
4ed47a1b2d24
generatorset: implement __nonzero__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22738
diff
changeset
|
784 |
def __nonzero__(self): |
24936
2aa94b6fe51c
revset: make generatorset.__nonzero__ lazy
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
24932
diff
changeset
|
785 |
# Do not use 'for r in self' because it will enforce the iteration |
2aa94b6fe51c
revset: make generatorset.__nonzero__ lazy
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
24932
diff
changeset
|
786 |
# order (default ascending), possibly unrolling a whole descending |
2aa94b6fe51c
revset: make generatorset.__nonzero__ lazy
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
24932
diff
changeset
|
787 |
# iterator. |
2aa94b6fe51c
revset: make generatorset.__nonzero__ lazy
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
24932
diff
changeset
|
788 |
if self._genlist: |
2aa94b6fe51c
revset: make generatorset.__nonzero__ lazy
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
24932
diff
changeset
|
789 |
return True |
2aa94b6fe51c
revset: make generatorset.__nonzero__ lazy
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
24932
diff
changeset
|
790 |
for r in self._consumegen(): |
22739
4ed47a1b2d24
generatorset: implement __nonzero__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22738
diff
changeset
|
791 |
return True |
4ed47a1b2d24
generatorset: implement __nonzero__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22738
diff
changeset
|
792 |
return False |
4ed47a1b2d24
generatorset: implement __nonzero__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22738
diff
changeset
|
793 |
|
31476
413b44003462
py3: add __bool__ to every class defining __nonzero__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31446
diff
changeset
|
794 |
__bool__ = __nonzero__ |
413b44003462
py3: add __bool__ to every class defining __nonzero__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31446
diff
changeset
|
795 |
|
20536
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
796 |
def __contains__(self, x): |
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
797 |
if x in self._cache: |
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
798 |
return self._cache[x] |
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
799 |
|
20828
3210b7930899
revset: improve performance of _generatorset.__contains__ (issue 4201)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
20780
diff
changeset
|
800 |
# Use new values only, as existing values would be cached. |
3210b7930899
revset: improve performance of _generatorset.__contains__ (issue 4201)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
20780
diff
changeset
|
801 |
for l in self._consumegen(): |
20634
f2bb7ba59456
revset: changed generatorset code to remove unnecesary function call
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20613
diff
changeset
|
802 |
if l == x: |
f2bb7ba59456
revset: changed generatorset code to remove unnecesary function call
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20613
diff
changeset
|
803 |
return True |
20536
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
804 |
|
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
805 |
self._cache[x] = False |
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
806 |
return False |
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
807 |
|
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
808 |
def __iter__(self): |
22800
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
809 |
if self._ascending: |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
810 |
it = self.fastasc |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
811 |
else: |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
812 |
it = self.fastdesc |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
813 |
if it is not None: |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
814 |
return it() |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
815 |
# we need to consume the iterator |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
816 |
for x in self._consumegen(): |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
817 |
pass |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
818 |
# recall the same code |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
819 |
return iter(self) |
22797
61ecabeeadb3
generatorset: move iteration code into _iterator
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22796
diff
changeset
|
820 |
|
61ecabeeadb3
generatorset: move iteration code into _iterator
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22796
diff
changeset
|
821 |
def _iterator(self): |
20833
47d43e2323c5
revset: fix generatorset race condition
Durham Goode <durham@fb.com>
parents:
20829
diff
changeset
|
822 |
if self._finished: |
22670
44dce874de97
revset: rely on built in iterator when possible in _generatorset.__iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22669
diff
changeset
|
823 |
return iter(self._genlist) |
20833
47d43e2323c5
revset: fix generatorset race condition
Durham Goode <durham@fb.com>
parents:
20829
diff
changeset
|
824 |
|
22494
14f6cebfcb8a
revset: document the choice made in __generatorset.__iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22487
diff
changeset
|
825 |
# We have to use this complex iteration strategy to allow multiple |
14f6cebfcb8a
revset: document the choice made in __generatorset.__iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22487
diff
changeset
|
826 |
# iterations at the same time. We need to be able to catch revision |
23139
e53f6b72a0e4
spelling: fixes from proofreading of spell checker issues
Mads Kiilerich <madski@unity3d.com>
parents:
23127
diff
changeset
|
827 |
# removed from _consumegen and added to genlist in another instance. |
22494
14f6cebfcb8a
revset: document the choice made in __generatorset.__iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22487
diff
changeset
|
828 |
# |
14f6cebfcb8a
revset: document the choice made in __generatorset.__iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22487
diff
changeset
|
829 |
# Getting rid of it would provide an about 15% speed up on this |
14f6cebfcb8a
revset: document the choice made in __generatorset.__iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22487
diff
changeset
|
830 |
# iteration. |
20833
47d43e2323c5
revset: fix generatorset race condition
Durham Goode <durham@fb.com>
parents:
20829
diff
changeset
|
831 |
genlist = self._genlist |
31446
9a94239e4f12
py3: use next() to obtain next item from inner generator of generatorset
Yuya Nishihara <yuya@tcha.org>
parents:
31127
diff
changeset
|
832 |
nextgen = self._consumegen() |
9a94239e4f12
py3: use next() to obtain next item from inner generator of generatorset
Yuya Nishihara <yuya@tcha.org>
parents:
31127
diff
changeset
|
833 |
_len, _next = len, next # cache global lookup |
22670
44dce874de97
revset: rely on built in iterator when possible in _generatorset.__iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22669
diff
changeset
|
834 |
def gen(): |
44dce874de97
revset: rely on built in iterator when possible in _generatorset.__iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22669
diff
changeset
|
835 |
i = 0 |
44dce874de97
revset: rely on built in iterator when possible in _generatorset.__iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22669
diff
changeset
|
836 |
while True: |
44dce874de97
revset: rely on built in iterator when possible in _generatorset.__iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22669
diff
changeset
|
837 |
if i < _len(genlist): |
44dce874de97
revset: rely on built in iterator when possible in _generatorset.__iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22669
diff
changeset
|
838 |
yield genlist[i] |
44dce874de97
revset: rely on built in iterator when possible in _generatorset.__iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22669
diff
changeset
|
839 |
else: |
32977
27ba0d8dc26c
py3: catch StopIteration from next() in generatorset
Martin von Zweigbergk <martinvonz@google.com>
parents:
32821
diff
changeset
|
840 |
try: |
27ba0d8dc26c
py3: catch StopIteration from next() in generatorset
Martin von Zweigbergk <martinvonz@google.com>
parents:
32821
diff
changeset
|
841 |
yield _next(nextgen) |
27ba0d8dc26c
py3: catch StopIteration from next() in generatorset
Martin von Zweigbergk <martinvonz@google.com>
parents:
32821
diff
changeset
|
842 |
except StopIteration: |
27ba0d8dc26c
py3: catch StopIteration from next() in generatorset
Martin von Zweigbergk <martinvonz@google.com>
parents:
32821
diff
changeset
|
843 |
return |
22670
44dce874de97
revset: rely on built in iterator when possible in _generatorset.__iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22669
diff
changeset
|
844 |
i += 1 |
44dce874de97
revset: rely on built in iterator when possible in _generatorset.__iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22669
diff
changeset
|
845 |
return gen() |
20828
3210b7930899
revset: improve performance of _generatorset.__contains__ (issue 4201)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
20780
diff
changeset
|
846 |
|
3210b7930899
revset: improve performance of _generatorset.__contains__ (issue 4201)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
20780
diff
changeset
|
847 |
def _consumegen(self): |
22528
b6dc3b79bb25
revset: avoid in loop lookup in _generatorset._consumegen
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22527
diff
changeset
|
848 |
cache = self._cache |
b6dc3b79bb25
revset: avoid in loop lookup in _generatorset._consumegen
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22527
diff
changeset
|
849 |
genlist = self._genlist.append |
20634
f2bb7ba59456
revset: changed generatorset code to remove unnecesary function call
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20613
diff
changeset
|
850 |
for item in self._gen: |
22528
b6dc3b79bb25
revset: avoid in loop lookup in _generatorset._consumegen
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22527
diff
changeset
|
851 |
cache[item] = True |
b6dc3b79bb25
revset: avoid in loop lookup in _generatorset._consumegen
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22527
diff
changeset
|
852 |
genlist(item) |
20634
f2bb7ba59456
revset: changed generatorset code to remove unnecesary function call
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20613
diff
changeset
|
853 |
yield item |
22798
586d7058ea48
generatorset: get list-based fast iterations after the generator is consumed
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22797
diff
changeset
|
854 |
if not self._finished: |
586d7058ea48
generatorset: get list-based fast iterations after the generator is consumed
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22797
diff
changeset
|
855 |
self._finished = True |
586d7058ea48
generatorset: get list-based fast iterations after the generator is consumed
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22797
diff
changeset
|
856 |
asc = self._genlist[:] |
586d7058ea48
generatorset: get list-based fast iterations after the generator is consumed
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22797
diff
changeset
|
857 |
asc.sort() |
586d7058ea48
generatorset: get list-based fast iterations after the generator is consumed
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22797
diff
changeset
|
858 |
self._asclist = asc |
586d7058ea48
generatorset: get list-based fast iterations after the generator is consumed
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22797
diff
changeset
|
859 |
self.fastasc = asc.__iter__ |
586d7058ea48
generatorset: get list-based fast iterations after the generator is consumed
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22797
diff
changeset
|
860 |
self.fastdesc = asc.__reversed__ |
20703
e07b1fd30805
revset: added sort methods to generatorsets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20695
diff
changeset
|
861 |
|
22996
a43d929d1fa1
generatorset: implement __len__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22995
diff
changeset
|
862 |
def __len__(self): |
a43d929d1fa1
generatorset: implement __len__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22995
diff
changeset
|
863 |
for x in self._consumegen(): |
a43d929d1fa1
generatorset: implement __len__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22995
diff
changeset
|
864 |
pass |
a43d929d1fa1
generatorset: implement __len__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22995
diff
changeset
|
865 |
return len(self._genlist) |
a43d929d1fa1
generatorset: implement __len__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22995
diff
changeset
|
866 |
|
20703
e07b1fd30805
revset: added sort methods to generatorsets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20695
diff
changeset
|
867 |
def sort(self, reverse=False): |
22800
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
868 |
self._ascending = not reverse |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
869 |
|
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
870 |
def reverse(self): |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
871 |
self._ascending = not self._ascending |
20703
e07b1fd30805
revset: added sort methods to generatorsets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20695
diff
changeset
|
872 |
|
22801
6af9e9b6af39
generatorset: implement isascending and isdescending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22800
diff
changeset
|
873 |
def isascending(self): |
6af9e9b6af39
generatorset: implement isascending and isdescending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22800
diff
changeset
|
874 |
return self._ascending |
6af9e9b6af39
generatorset: implement isascending and isdescending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22800
diff
changeset
|
875 |
|
6af9e9b6af39
generatorset: implement isascending and isdescending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22800
diff
changeset
|
876 |
def isdescending(self): |
6af9e9b6af39
generatorset: implement isascending and isdescending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22800
diff
changeset
|
877 |
return not self._ascending |
6af9e9b6af39
generatorset: implement isascending and isdescending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22800
diff
changeset
|
878 |
|
29346
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
879 |
def istopo(self): |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
880 |
# not worth the trouble asserting if the two sets combined are still |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
881 |
# in topographical order. Use the sort() predicate to explicitly sort |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
882 |
# again instead. |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
883 |
return False |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
884 |
|
22811
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
885 |
def first(self): |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
886 |
if self._ascending: |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
887 |
it = self.fastasc |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
888 |
else: |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
889 |
it = self.fastdesc |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
890 |
if it is None: |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
891 |
# we need to consume all and try again |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
892 |
for x in self._consumegen(): |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
893 |
pass |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
894 |
return self.first() |
25146
f542a2c89b60
generatorset: use 'next()' to simplify the code
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25145
diff
changeset
|
895 |
return next(it(), None) |
22811
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
896 |
|
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
897 |
def last(self): |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
898 |
if self._ascending: |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
899 |
it = self.fastdesc |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
900 |
else: |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
901 |
it = self.fastasc |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
902 |
if it is None: |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
903 |
# we need to consume all and try again |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
904 |
for x in self._consumegen(): |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
905 |
pass |
33109
247bae545061
smartset: fix generatorset.last() to not return the first element (issue5609)
Yuya Nishihara <yuya@tcha.org>
parents:
33072
diff
changeset
|
906 |
return self.last() |
25146
f542a2c89b60
generatorset: use 'next()' to simplify the code
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25145
diff
changeset
|
907 |
return next(it(), None) |
22811
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
908 |
|
35901
f0827211eb1f
py3: build repr() of smartset as bytes then convert to str
Yuya Nishihara <yuya@tcha.org>
parents:
35838
diff
changeset
|
909 |
@encoding.strmethod |
24457
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
910 |
def __repr__(self): |
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
911 |
d = {False: '-', True: '+'}[self._ascending] |
35901
f0827211eb1f
py3: build repr() of smartset as bytes then convert to str
Yuya Nishihara <yuya@tcha.org>
parents:
35838
diff
changeset
|
912 |
return '<%s%s>' % (_typename(self), d) |
35501
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
913 |
|
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
914 |
class _generatorsetasc(generatorset): |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
915 |
"""Special case of generatorset optimized for ascending generators.""" |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
916 |
|
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
917 |
fastasc = generatorset._iterator |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
918 |
|
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
919 |
def __contains__(self, x): |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
920 |
if x in self._cache: |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
921 |
return self._cache[x] |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
922 |
|
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
923 |
# Use new values only, as existing values would be cached. |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
924 |
for l in self._consumegen(): |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
925 |
if l == x: |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
926 |
return True |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
927 |
if l > x: |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
928 |
break |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
929 |
|
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
930 |
self._cache[x] = False |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
931 |
return False |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
932 |
|
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
933 |
class _generatorsetdesc(generatorset): |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
934 |
"""Special case of generatorset optimized for descending generators.""" |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
935 |
|
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
936 |
fastdesc = generatorset._iterator |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
937 |
|
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
938 |
def __contains__(self, x): |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
939 |
if x in self._cache: |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
940 |
return self._cache[x] |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
941 |
|
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
942 |
# Use new values only, as existing values would be cached. |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
943 |
for l in self._consumegen(): |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
944 |
if l == x: |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
945 |
return True |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
946 |
if l < x: |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
947 |
break |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
948 |
|
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
949 |
self._cache[x] = False |
12a46ad67a3c
smartset: split generatorset classes to avoid cycle
Gregory Szorc <gregory.szorc@gmail.com>
parents:
34070
diff
changeset
|
950 |
return False |
24457
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
951 |
|
32818
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
952 |
def spanset(repo, start=0, end=None): |
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
953 |
"""Create a spanset that represents a range of repository revisions |
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
954 |
|
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
955 |
start: first revision included the set (default to 0) |
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
956 |
end: first revision excluded (last+1) (default to len(repo)) |
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
957 |
|
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
958 |
Spanset will be descending if `end` < `start`. |
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
959 |
""" |
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
960 |
if end is None: |
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
961 |
end = len(repo) |
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
962 |
ascending = start <= end |
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
963 |
if not ascending: |
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
964 |
start, end = end + 1, start + 1 |
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
965 |
return _spanset(start, end, ascending, repo.changelog.filteredrevs) |
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
966 |
|
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
967 |
class _spanset(abstractsmartset): |
20482
a979078bd788
revset: added spanset class to represent revision ranges
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20481
diff
changeset
|
968 |
"""Duck type for baseset class which represents a range of revisions and |
a979078bd788
revset: added spanset class to represent revision ranges
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20481
diff
changeset
|
969 |
can work lazily and without having all the range in memory |
20737
b141080e70c5
revset: added documentation and comment for spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20734
diff
changeset
|
970 |
|
b141080e70c5
revset: added documentation and comment for spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20734
diff
changeset
|
971 |
Note that spanset(x, y) behave almost like xrange(x, y) except for two |
b141080e70c5
revset: added documentation and comment for spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20734
diff
changeset
|
972 |
notable points: |
b141080e70c5
revset: added documentation and comment for spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20734
diff
changeset
|
973 |
- when x < y it will be automatically descending, |
b141080e70c5
revset: added documentation and comment for spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20734
diff
changeset
|
974 |
- revision filtered with this repoview will be skipped. |
b141080e70c5
revset: added documentation and comment for spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20734
diff
changeset
|
975 |
|
20482
a979078bd788
revset: added spanset class to represent revision ranges
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20481
diff
changeset
|
976 |
""" |
32818
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
977 |
def __init__(self, start, end, ascending, hiddenrevs): |
20482
a979078bd788
revset: added spanset class to represent revision ranges
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20481
diff
changeset
|
978 |
self._start = start |
22717
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
979 |
self._end = end |
32818
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
980 |
self._ascending = ascending |
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
981 |
self._hiddenrevs = hiddenrevs |
20521
1850a7f5fb66
revset: changed spanset implementation to take hidden revisions into account
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20512
diff
changeset
|
982 |
|
22717
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
983 |
def sort(self, reverse=False): |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
984 |
self._ascending = not reverse |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
985 |
|
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
986 |
def reverse(self): |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
987 |
self._ascending = not self._ascending |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
988 |
|
29346
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
989 |
def istopo(self): |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
990 |
# not worth the trouble asserting if the two sets combined are still |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
991 |
# in topographical order. Use the sort() predicate to explicitly sort |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
992 |
# again instead. |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
993 |
return False |
38e0c83c7ee4
revset: record if a set is in topographical order
Martijn Pieters <mjpieters@fb.com>
parents:
29304
diff
changeset
|
994 |
|
22717
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
995 |
def _iterfilter(self, iterrange): |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
996 |
s = self._hiddenrevs |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
997 |
for r in iterrange: |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
998 |
if r not in s: |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
999 |
yield r |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
1000 |
|
20482
a979078bd788
revset: added spanset class to represent revision ranges
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20481
diff
changeset
|
1001 |
def __iter__(self): |
22717
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
1002 |
if self._ascending: |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
1003 |
return self.fastasc() |
20482
a979078bd788
revset: added spanset class to represent revision ranges
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20481
diff
changeset
|
1004 |
else: |
22717
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
1005 |
return self.fastdesc() |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
1006 |
|
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
1007 |
def fastasc(self): |
38783
e7aa113b14f7
global: use pycompat.xrange()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38576
diff
changeset
|
1008 |
iterrange = pycompat.xrange(self._start, self._end) |
20521
1850a7f5fb66
revset: changed spanset implementation to take hidden revisions into account
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20512
diff
changeset
|
1009 |
if self._hiddenrevs: |
22717
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
1010 |
return self._iterfilter(iterrange) |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
1011 |
return iter(iterrange) |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
1012 |
|
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
1013 |
def fastdesc(self): |
38783
e7aa113b14f7
global: use pycompat.xrange()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38576
diff
changeset
|
1014 |
iterrange = pycompat.xrange(self._end - 1, self._start - 1, -1) |
22717
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
1015 |
if self._hiddenrevs: |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
1016 |
return self._iterfilter(iterrange) |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
1017 |
return iter(iterrange) |
20482
a979078bd788
revset: added spanset class to represent revision ranges
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20481
diff
changeset
|
1018 |
|
21201
c8b9c6147108
revset: fix revision filtering in spanset.contains (regression)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21199
diff
changeset
|
1019 |
def __contains__(self, rev): |
22526
1e6d2b6b37ea
revset: do less lookup during spanset.__contains__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22510
diff
changeset
|
1020 |
hidden = self._hiddenrevs |
22718
7b123e5639f4
spanset: do a single range check in __contains__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22717
diff
changeset
|
1021 |
return ((self._start <= rev < self._end) |
22526
1e6d2b6b37ea
revset: do less lookup during spanset.__contains__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22510
diff
changeset
|
1022 |
and not (hidden and rev in hidden)) |
20482
a979078bd788
revset: added spanset class to represent revision ranges
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20481
diff
changeset
|
1023 |
|
20716
fa1ac5faa7c4
revset: added __nonzero__ method to spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20714
diff
changeset
|
1024 |
def __nonzero__(self): |
fa1ac5faa7c4
revset: added __nonzero__ method to spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20714
diff
changeset
|
1025 |
for r in self: |
fa1ac5faa7c4
revset: added __nonzero__ method to spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20714
diff
changeset
|
1026 |
return True |
fa1ac5faa7c4
revset: added __nonzero__ method to spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20714
diff
changeset
|
1027 |
return False |
fa1ac5faa7c4
revset: added __nonzero__ method to spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20714
diff
changeset
|
1028 |
|
31476
413b44003462
py3: add __bool__ to every class defining __nonzero__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31446
diff
changeset
|
1029 |
__bool__ = __nonzero__ |
413b44003462
py3: add __bool__ to every class defining __nonzero__
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31446
diff
changeset
|
1030 |
|
20484
0f1ef9e9e904
revset: added operations to spanset to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20483
diff
changeset
|
1031 |
def __len__(self): |
20521
1850a7f5fb66
revset: changed spanset implementation to take hidden revisions into account
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20512
diff
changeset
|
1032 |
if not self._hiddenrevs: |
1850a7f5fb66
revset: changed spanset implementation to take hidden revisions into account
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20512
diff
changeset
|
1033 |
return abs(self._end - self._start) |
1850a7f5fb66
revset: changed spanset implementation to take hidden revisions into account
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20512
diff
changeset
|
1034 |
else: |
1850a7f5fb66
revset: changed spanset implementation to take hidden revisions into account
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20512
diff
changeset
|
1035 |
count = 0 |
21205
e2031c8ca4f8
revset: also inline spanset._contained in __len__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21204
diff
changeset
|
1036 |
start = self._start |
e2031c8ca4f8
revset: also inline spanset._contained in __len__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21204
diff
changeset
|
1037 |
end = self._end |
20521
1850a7f5fb66
revset: changed spanset implementation to take hidden revisions into account
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20512
diff
changeset
|
1038 |
for rev in self._hiddenrevs: |
21284
3e53a64345c1
revset: cosmetic changes in spanset range comparison
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21283
diff
changeset
|
1039 |
if (end < rev <= start) or (start <= rev < end): |
20521
1850a7f5fb66
revset: changed spanset implementation to take hidden revisions into account
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20512
diff
changeset
|
1040 |
count += 1 |
1850a7f5fb66
revset: changed spanset implementation to take hidden revisions into account
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20512
diff
changeset
|
1041 |
return abs(self._end - self._start) - count |
20484
0f1ef9e9e904
revset: added operations to spanset to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20483
diff
changeset
|
1042 |
|
20725
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
1043 |
def isascending(self): |
23826
c90d195320c5
revset: fix spanset.isascending() to honor sort() or reverse() request
Yuya Nishihara <yuya@tcha.org>
parents:
23724
diff
changeset
|
1044 |
return self._ascending |
20725
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
1045 |
|
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
1046 |
def isdescending(self): |
23826
c90d195320c5
revset: fix spanset.isascending() to honor sort() or reverse() request
Yuya Nishihara <yuya@tcha.org>
parents:
23724
diff
changeset
|
1047 |
return not self._ascending |
20725
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
1048 |
|
22809
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
1049 |
def first(self): |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
1050 |
if self._ascending: |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
1051 |
it = self.fastasc |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
1052 |
else: |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
1053 |
it = self.fastdesc |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
1054 |
for x in it(): |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
1055 |
return x |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
1056 |
return None |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
1057 |
|
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
1058 |
def last(self): |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
1059 |
if self._ascending: |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
1060 |
it = self.fastdesc |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
1061 |
else: |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
1062 |
it = self.fastasc |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
1063 |
for x in it(): |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
1064 |
return x |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
1065 |
return None |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
1066 |
|
32821
9b7d615108d7
smartset: micro optimize spanset.slice() to narrow range accordingly
Yuya Nishihara <yuya@tcha.org>
parents:
32820
diff
changeset
|
1067 |
def _slice(self, start, stop): |
9b7d615108d7
smartset: micro optimize spanset.slice() to narrow range accordingly
Yuya Nishihara <yuya@tcha.org>
parents:
32820
diff
changeset
|
1068 |
if self._hiddenrevs: |
9b7d615108d7
smartset: micro optimize spanset.slice() to narrow range accordingly
Yuya Nishihara <yuya@tcha.org>
parents:
32820
diff
changeset
|
1069 |
# unoptimized since all hidden revisions in range has to be scanned |
9b7d615108d7
smartset: micro optimize spanset.slice() to narrow range accordingly
Yuya Nishihara <yuya@tcha.org>
parents:
32820
diff
changeset
|
1070 |
return super(_spanset, self)._slice(start, stop) |
9b7d615108d7
smartset: micro optimize spanset.slice() to narrow range accordingly
Yuya Nishihara <yuya@tcha.org>
parents:
32820
diff
changeset
|
1071 |
if self._ascending: |
9b7d615108d7
smartset: micro optimize spanset.slice() to narrow range accordingly
Yuya Nishihara <yuya@tcha.org>
parents:
32820
diff
changeset
|
1072 |
x = min(self._start + start, self._end) |
9b7d615108d7
smartset: micro optimize spanset.slice() to narrow range accordingly
Yuya Nishihara <yuya@tcha.org>
parents:
32820
diff
changeset
|
1073 |
y = min(self._start + stop, self._end) |
9b7d615108d7
smartset: micro optimize spanset.slice() to narrow range accordingly
Yuya Nishihara <yuya@tcha.org>
parents:
32820
diff
changeset
|
1074 |
else: |
9b7d615108d7
smartset: micro optimize spanset.slice() to narrow range accordingly
Yuya Nishihara <yuya@tcha.org>
parents:
32820
diff
changeset
|
1075 |
x = max(self._end - stop, self._start) |
9b7d615108d7
smartset: micro optimize spanset.slice() to narrow range accordingly
Yuya Nishihara <yuya@tcha.org>
parents:
32820
diff
changeset
|
1076 |
y = max(self._end - start, self._start) |
9b7d615108d7
smartset: micro optimize spanset.slice() to narrow range accordingly
Yuya Nishihara <yuya@tcha.org>
parents:
32820
diff
changeset
|
1077 |
return _spanset(x, y, self._ascending, self._hiddenrevs) |
9b7d615108d7
smartset: micro optimize spanset.slice() to narrow range accordingly
Yuya Nishihara <yuya@tcha.org>
parents:
32820
diff
changeset
|
1078 |
|
35901
f0827211eb1f
py3: build repr() of smartset as bytes then convert to str
Yuya Nishihara <yuya@tcha.org>
parents:
35838
diff
changeset
|
1079 |
@encoding.strmethod |
24457
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
1080 |
def __repr__(self): |
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
1081 |
d = {False: '-', True: '+'}[self._ascending] |
35901
f0827211eb1f
py3: build repr() of smartset as bytes then convert to str
Yuya Nishihara <yuya@tcha.org>
parents:
35838
diff
changeset
|
1082 |
return '<%s%s %d:%d>' % (_typename(self), d, self._start, self._end) |
24457
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
1083 |
|
32818
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
1084 |
class fullreposet(_spanset): |
22508
2434c68d82a8
revert: add a fullreposet class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22504
diff
changeset
|
1085 |
"""a set containing all revisions in the repo |
2434c68d82a8
revert: add a fullreposet class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22504
diff
changeset
|
1086 |
|
24204
d2de20e1451f
revset: extend fullreposet to make "null" revision magically appears in set
Yuya Nishihara <yuya@tcha.org>
parents:
24203
diff
changeset
|
1087 |
This class exists to host special optimization and magic to handle virtual |
d2de20e1451f
revset: extend fullreposet to make "null" revision magically appears in set
Yuya Nishihara <yuya@tcha.org>
parents:
24203
diff
changeset
|
1088 |
revisions such as "null". |
22508
2434c68d82a8
revert: add a fullreposet class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22504
diff
changeset
|
1089 |
""" |
2434c68d82a8
revert: add a fullreposet class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22504
diff
changeset
|
1090 |
|
2434c68d82a8
revert: add a fullreposet class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22504
diff
changeset
|
1091 |
def __init__(self, repo): |
32818
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
1092 |
super(fullreposet, self).__init__(0, len(repo), True, |
9ddb18ae342e
smartset: extract spanset factory to make it constructed without a repo
Yuya Nishihara <yuya@tcha.org>
parents:
32817
diff
changeset
|
1093 |
repo.changelog.filteredrevs) |
22508
2434c68d82a8
revert: add a fullreposet class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22504
diff
changeset
|
1094 |
|
22510
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
1095 |
def __and__(self, other): |
23139
e53f6b72a0e4
spelling: fixes from proofreading of spell checker issues
Mads Kiilerich <madski@unity3d.com>
parents:
23127
diff
changeset
|
1096 |
"""As self contains the whole repo, all of the other set should also be |
e53f6b72a0e4
spelling: fixes from proofreading of spell checker issues
Mads Kiilerich <madski@unity3d.com>
parents:
23127
diff
changeset
|
1097 |
in self. Therefore `self & other = other`. |
22510
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
1098 |
|
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
1099 |
This boldly assumes the other contains valid revs only. |
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
1100 |
""" |
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
1101 |
# other not a smartset, make is so |
22883
e7b8cf352614
fullreposet: detect smartset using "isascending" instead of "set"
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22882
diff
changeset
|
1102 |
if not util.safehasattr(other, 'isascending'): |
22510
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
1103 |
# filter out hidden revision |
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
1104 |
# (this boldly assumes all smartset are pure) |
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
1105 |
# |
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
1106 |
# `other` was used with "&", let's assume this is a set like |
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
1107 |
# object. |
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
1108 |
other = baseset(other - self._hiddenrevs) |
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
1109 |
|
23827
4982fade9733
revset: simplify fullreposet.__and__ to call sort() with boolean flag
Yuya Nishihara <yuya@tcha.org>
parents:
23822
diff
changeset
|
1110 |
other.sort(reverse=self.isdescending()) |
22510
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
1111 |
return other |