1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45 package org.eclipse.jgit.treewalk.filter;
46
47 import java.io.IOException;
48 import java.util.Collection;
49
50 import org.eclipse.jgit.errors.IncorrectObjectTypeException;
51 import org.eclipse.jgit.errors.MissingObjectException;
52 import org.eclipse.jgit.internal.JGitText;
53 import org.eclipse.jgit.treewalk.TreeWalk;
54
55
56
57
58
59
60
61
62
63
64 public abstract class OrTreeFilter extends TreeFilter {
65
66
67
68
69
70
71
72
73
74 public static TreeFilter create(TreeFilter a, TreeFilter b) {
75 if (a == ALL || b == ALL)
76 return ALL;
77 return new Binary(a, b);
78 }
79
80
81
82
83
84
85
86
87
88 public static TreeFilter create(TreeFilter[] list) {
89 if (list.length == 2)
90 return create(list[0], list[1]);
91 if (list.length < 2)
92 throw new IllegalArgumentException(JGitText.get().atLeastTwoFiltersNeeded);
93 final TreeFilter[] subfilters = new TreeFilter[list.length];
94 System.arraycopy(list, 0, subfilters, 0, list.length);
95 return new List(subfilters);
96 }
97
98
99
100
101
102
103
104
105
106 public static TreeFilter create(Collection<TreeFilter> list) {
107 if (list.size() < 2)
108 throw new IllegalArgumentException(JGitText.get().atLeastTwoFiltersNeeded);
109 final TreeFilter[] subfilters = new TreeFilter[list.size()];
110 list.toArray(subfilters);
111 if (subfilters.length == 2)
112 return create(subfilters[0], subfilters[1]);
113 return new List(subfilters);
114 }
115
116 private static class Binary extends OrTreeFilter {
117 private final TreeFilter a;
118
119 private final TreeFilter b;
120
121 Binary(TreeFilter one, TreeFilter two) {
122 a = one;
123 b = two;
124 }
125
126 @Override
127 public boolean include(TreeWalk walker)
128 throws MissingObjectException, IncorrectObjectTypeException,
129 IOException {
130 return matchFilter(walker) <= 0;
131 }
132
133 @Override
134 public int matchFilter(TreeWalk walker)
135 throws MissingObjectException, IncorrectObjectTypeException,
136 IOException {
137 final int ra = a.matchFilter(walker);
138 if (ra == 0) {
139 return 0;
140 }
141 final int rb = b.matchFilter(walker);
142 if (rb == 0) {
143 return 0;
144 }
145 if (ra == -1 || rb == -1) {
146 return -1;
147 }
148 return 1;
149 }
150
151 @Override
152 public boolean shouldBeRecursive() {
153 return a.shouldBeRecursive() || b.shouldBeRecursive();
154 }
155
156 @Override
157 public TreeFilter clone() {
158 return new Binary(a.clone(), b.clone());
159 }
160
161 @SuppressWarnings("nls")
162 @Override
163 public String toString() {
164 return "(" + a.toString() + " OR " + b.toString() + ")";
165 }
166 }
167
168 private static class List extends OrTreeFilter {
169 private final TreeFilter[] subfilters;
170
171 List(TreeFilter[] list) {
172 subfilters = list;
173 }
174
175 @Override
176 public boolean include(TreeWalk walker)
177 throws MissingObjectException, IncorrectObjectTypeException,
178 IOException {
179 return matchFilter(walker) <= 0;
180 }
181
182 @Override
183 public int matchFilter(TreeWalk walker)
184 throws MissingObjectException, IncorrectObjectTypeException,
185 IOException {
186 int m = 1;
187 for (TreeFilter f : subfilters) {
188 int r = f.matchFilter(walker);
189 if (r == 0) {
190 return 0;
191 }
192 if (r == -1) {
193 m = -1;
194 }
195 }
196 return m;
197 }
198
199 @Override
200 public boolean shouldBeRecursive() {
201 for (TreeFilter f : subfilters)
202 if (f.shouldBeRecursive())
203 return true;
204 return false;
205 }
206
207 @Override
208 public TreeFilter clone() {
209 final TreeFilter[] s = new TreeFilter[subfilters.length];
210 for (int i = 0; i < s.length; i++)
211 s[i] = subfilters[i].clone();
212 return new List(s);
213 }
214
215 @Override
216 public String toString() {
217 final StringBuilder r = new StringBuilder();
218 r.append("(");
219 for (int i = 0; i < subfilters.length; i++) {
220 if (i > 0)
221 r.append(" OR ");
222 r.append(subfilters[i].toString());
223 }
224 r.append(")");
225 return r.toString();
226 }
227 }
228 }