|
1
11 package org.eclipse.jdt.internal.ui.search;
12
13 import java.util.ArrayList  ;
14 import java.util.HashSet ;
15 import java.util.StringTokenizer ;
16
17 import org.eclipse.search.ui.text.Match;
18 import org.eclipse.search.ui.text.MatchFilter;
19
20 import org.eclipse.jdt.core.IField;
21 import org.eclipse.jdt.core.IImportDeclaration;
22 import org.eclipse.jdt.core.IJavaElement;
23 import org.eclipse.jdt.core.ILocalVariable;
24 import org.eclipse.jdt.core.IMember;
25 import org.eclipse.jdt.core.IMethod;
26 import org.eclipse.jdt.core.IPackageFragment;
27 import org.eclipse.jdt.core.IType;
28 import org.eclipse.jdt.core.ITypeParameter;
29 import org.eclipse.jdt.core.JavaModelException;
30 import org.eclipse.jdt.core.search.IJavaSearchConstants;
31 import org.eclipse.jdt.core.search.SearchMatch;
32 import org.eclipse.jdt.core.search.SearchPattern;
33
34 import org.eclipse.jdt.internal.corext.util.JdtFlags;
35
36 import org.eclipse.jdt.ui.search.ElementQuerySpecification;
37 import org.eclipse.jdt.ui.search.PatternQuerySpecification;
38 import org.eclipse.jdt.ui.search.QuerySpecification;
39
40 import org.eclipse.jdt.internal.ui.JavaPlugin;
41
42 abstract class JavaMatchFilter extends MatchFilter {
43
44 public abstract boolean filters(JavaElementMatch match);
45
46
51 public abstract boolean isApplicable(JavaSearchQuery query);
52
53
56 public boolean filters(Match match) {
57 if (match instanceof JavaElementMatch) {
58 return filters((JavaElementMatch) match);
59 }
60 return false;
61 }
62
63 private static final String SETTINGS_LAST_USED_FILTERS= "filters_last_used";
65 public static MatchFilter[] getLastUsedFilters() {
66 String string= JavaPlugin.getDefault().getDialogSettings().get(SETTINGS_LAST_USED_FILTERS);
67 if (string != null && string.length() > 0) {
68 return decodeFiltersString(string);
69 }
70 return getDefaultFilters();
71 }
72
73 public static void setLastUsedFilters(MatchFilter[] filters) {
74 String encoded= encodeFilters(filters);
75 JavaPlugin.getDefault().getDialogSettings().put(SETTINGS_LAST_USED_FILTERS, encoded);
76 }
77
78 public static MatchFilter[] getDefaultFilters() {
79 return new MatchFilter[] { IMPORT_FILTER };
80 }
81
82 private static String encodeFilters(MatchFilter[] enabledFilters) {
83 StringBuffer buf= new StringBuffer ();
84 for (int i= 0; i < enabledFilters.length; i++) {
85 MatchFilter matchFilter= enabledFilters[i];
86 buf.append(matchFilter.getID());
87 buf.append(';');
88 }
89 return buf.toString();
90 }
91
92 private static JavaMatchFilter[] decodeFiltersString(String encodedString) {
93 StringTokenizer tokenizer= new StringTokenizer (encodedString, String.valueOf(';'));
94 HashSet result= new HashSet ();
95 while (tokenizer.hasMoreTokens()) {
96 JavaMatchFilter curr= findMatchFilter(tokenizer.nextToken());
97 if (curr != null) {
98 result.add(curr);
99 }
100 }
101 return (JavaMatchFilter[]) result.toArray(new JavaMatchFilter[result.size()]);
102 }
103
104 private static final JavaMatchFilter POTENTIAL_FILTER= new PotentialFilter();
105 private static final JavaMatchFilter IMPORT_FILTER= new ImportFilter();
106 private static final JavaMatchFilter JAVADOC_FILTER= new JavadocFilter();
107 private static final JavaMatchFilter READ_FILTER= new ReadFilter();
108 private static final JavaMatchFilter WRITE_FILTER= new WriteFilter();
109
110 private static final JavaMatchFilter POLYMORPHIC_FILTER= new PolymorphicFilter();
111 private static final JavaMatchFilter INEXACT_FILTER= new InexactMatchFilter();
112 private static final JavaMatchFilter ERASURE_FILTER= new ErasureMatchFilter();
113
114 private static final JavaMatchFilter NON_PUBLIC_FILTER= new NonPublicFilter();
115 private static final JavaMatchFilter STATIC_FILTER= new StaticFilter();
116 private static final JavaMatchFilter NON_STATIC_FILTER= new NonStaticFilter();
117 private static final JavaMatchFilter DEPRECATED_FILTER= new DeprecatedFilter();
118 private static final JavaMatchFilter NON_DEPRECATED_FILTER= new NonDeprecatedFilter();
119
120 private static final JavaMatchFilter[] ALL_FILTERS= new JavaMatchFilter[] {
121 POTENTIAL_FILTER,
122 IMPORT_FILTER,
123 JAVADOC_FILTER,
124 READ_FILTER,
125 WRITE_FILTER,
126
127 POLYMORPHIC_FILTER,
128 INEXACT_FILTER,
129 ERASURE_FILTER,
130
131 NON_PUBLIC_FILTER,
132 STATIC_FILTER,
133 NON_STATIC_FILTER,
134 DEPRECATED_FILTER,
135 NON_DEPRECATED_FILTER
136 };
137
138 public static JavaMatchFilter[] allFilters() {
139 return ALL_FILTERS;
140 }
141
142 public static JavaMatchFilter[] allFilters(JavaSearchQuery query) {
143 ArrayList res= new ArrayList ();
144 for (int i= 0; i < ALL_FILTERS.length; i++) {
145 JavaMatchFilter curr= ALL_FILTERS[i];
146 if (curr.isApplicable(query)) {
147 res.add(curr);
148 }
149 }
150 return (JavaMatchFilter[]) res.toArray(new JavaMatchFilter[res.size()]);
151 }
152
153 private static JavaMatchFilter findMatchFilter(String id) {
154 for (int i= 0; i < ALL_FILTERS.length; i++) {
155 JavaMatchFilter matchFilter= ALL_FILTERS[i];
156 if (matchFilter.getID().equals(id))
157 return matchFilter;
158 }
159 return null;
160 }
161 }
162
163 class PotentialFilter extends JavaMatchFilter {
164 public boolean filters(JavaElementMatch match) {
165 return match.getAccuracy() == SearchMatch.A_INACCURATE;
166 }
167
168 public String getName() {
169 return SearchMessages.MatchFilter_PotentialFilter_name;
170 }
171
172 public String getActionLabel() {
173 return SearchMessages.MatchFilter_PotentialFilter_actionLabel;
174 }
175
176 public String getDescription() {
177 return SearchMessages.MatchFilter_PotentialFilter_description;
178 }
179
180 public boolean isApplicable(JavaSearchQuery query) {
181 return true;
182 }
183
184 public String getID() {
185 return "filter_potential"; }
187 }
188
189 class ImportFilter extends JavaMatchFilter {
190 public boolean filters(JavaElementMatch match) {
191 return match.getElement() instanceof IImportDeclaration;
192 }
193
194 public String getName() {
195 return SearchMessages.MatchFilter_ImportFilter_name;
196 }
197
198 public String getActionLabel() {
199 return SearchMessages.MatchFilter_ImportFilter_actionLabel;
200 }
201
202 public String getDescription() {
203 return SearchMessages.MatchFilter_ImportFilter_description;
204 }
205
206 public boolean isApplicable(JavaSearchQuery query) {
207 QuerySpecification spec= query.getSpecification();
208 if (spec instanceof ElementQuerySpecification) {
209 ElementQuerySpecification elementSpec= (ElementQuerySpecification) spec;
210 IJavaElement element= elementSpec.getElement();
211 return element instanceof IType || element instanceof IPackageFragment;
212 } else if (spec instanceof PatternQuerySpecification) {
213 PatternQuerySpecification patternSpec= (PatternQuerySpecification) spec;
214 int searchFor= patternSpec.getSearchFor();
215 return searchFor == IJavaSearchConstants.TYPE || searchFor == IJavaSearchConstants.PACKAGE;
216 }
217 return false;
218 }
219
220 public String getID() {
221 return "filter_imports"; }
223 }
224
225 abstract class VariableFilter extends JavaMatchFilter {
226 public boolean isApplicable(JavaSearchQuery query) {
227 QuerySpecification spec= query.getSpecification();
228 if (spec instanceof ElementQuerySpecification) {
229 ElementQuerySpecification elementSpec= (ElementQuerySpecification) spec;
230 IJavaElement element= elementSpec.getElement();
231 return element instanceof IField || element instanceof ILocalVariable;
232 } else if (spec instanceof PatternQuerySpecification) {
233 PatternQuerySpecification patternSpec= (PatternQuerySpecification) spec;
234 return patternSpec.getSearchFor() == IJavaSearchConstants.FIELD;
235 }
236 return false;
237 }
238
239 }
240
241 class WriteFilter extends VariableFilter {
242 public boolean filters(JavaElementMatch match) {
243 return match.isWriteAccess() && !match.isReadAccess();
244 }
245 public String getName() {
246 return SearchMessages.MatchFilter_WriteFilter_name;
247 }
248 public String getActionLabel() {
249 return SearchMessages.MatchFilter_WriteFilter_actionLabel;
250 }
251 public String getDescription() {
252 return SearchMessages.MatchFilter_WriteFilter_description;
253 }
254 public String getID() {
255 return "filter_writes"; }
257 }
258
259 class ReadFilter extends VariableFilter {
260 public boolean filters(JavaElementMatch match) {
261 return match.isReadAccess() && !match.isWriteAccess();
262 }
263 public String getName() {
264 return SearchMessages.MatchFilter_ReadFilter_name;
265 }
266 public String getActionLabel() {
267 return SearchMessages.MatchFilter_ReadFilter_actionLabel;
268 }
269 public String getDescription() {
270 return SearchMessages.MatchFilter_ReadFilter_description;
271 }
272 public String getID() {
273 return "filter_reads"; }
275 }
276
277 class JavadocFilter extends JavaMatchFilter {
278 public boolean filters(JavaElementMatch match) {
279 return match.isJavadoc();
280 }
281 public String getName() {
282 return SearchMessages.MatchFilter_JavadocFilter_name;
283 }
284 public String getActionLabel() {
285 return SearchMessages.MatchFilter_JavadocFilter_actionLabel;
286 }
287 public String getDescription() {
288 return SearchMessages.MatchFilter_JavadocFilter_description;
289 }
290 public boolean isApplicable(JavaSearchQuery query) {
291 return true;
292 }
293 public String getID() {
294 return "filter_javadoc"; }
296 }
297
298 class PolymorphicFilter extends JavaMatchFilter {
299 public boolean filters(JavaElementMatch match) {
300 return match.isSuperInvocation();
301 }
302
303 public String getName() {
304 return SearchMessages.MatchFilter_PolymorphicFilter_name;
305 }
306
307 public String getActionLabel() {
308 return SearchMessages.MatchFilter_PolymorphicFilter_actionLabel;
309 }
310
311 public String getDescription() {
312 return SearchMessages.MatchFilter_PolymorphicFilter_description;
313 }
314
315 public boolean isApplicable(JavaSearchQuery query) {
316 QuerySpecification spec= query.getSpecification();
317 switch (spec.getLimitTo()) {
318 case IJavaSearchConstants.REFERENCES:
319 case IJavaSearchConstants.ALL_OCCURRENCES:
320 if (spec instanceof ElementQuerySpecification) {
321 ElementQuerySpecification elementSpec= (ElementQuerySpecification) spec;
322 return elementSpec.getElement() instanceof IMethod;
323 } else if (spec instanceof PatternQuerySpecification) {
324 PatternQuerySpecification patternSpec= (PatternQuerySpecification) spec;
325 return patternSpec.getSearchFor() == IJavaSearchConstants.METHOD;
326 }
327 }
328 return false;
329 }
330
331 public String getID() {
332 return "filter_polymorphic"; }
334 }
335
336 abstract class GenericTypeFilter extends JavaMatchFilter {
337 public boolean isApplicable(JavaSearchQuery query) {
338 QuerySpecification spec= query.getSpecification();
339 if (spec instanceof ElementQuerySpecification) {
340 ElementQuerySpecification elementSpec= (ElementQuerySpecification) spec;
341 Object element= elementSpec.getElement();
342 ITypeParameter[] typeParameters= null;
343 try {
344 if (element instanceof IType) {
345 typeParameters= ((IType)element).getTypeParameters();
346 } else if (element instanceof IMethod) {
347 typeParameters= ((IMethod)element).getTypeParameters();
348 }
349 } catch (JavaModelException e) {
350 return false;
351 }
352 return typeParameters != null && typeParameters.length > 0;
353 }
354 return false;
355 }
356 }
357
358 class ErasureMatchFilter extends GenericTypeFilter {
359 public boolean filters(JavaElementMatch match) {
360 return (match.getMatchRule() & (SearchPattern.R_FULL_MATCH | SearchPattern.R_EQUIVALENT_MATCH)) == 0;
361 }
362 public String getName() {
363 return SearchMessages.MatchFilter_ErasureFilter_name;
364 }
365 public String getActionLabel() {
366 return SearchMessages.MatchFilter_ErasureFilter_actionLabel;
367 }
368 public String getDescription() {
369 return SearchMessages.MatchFilter_ErasureFilter_description;
370 }
371 public String getID() {
372 return "filter_erasure"; }
374 }
375
376 class InexactMatchFilter extends GenericTypeFilter {
377 public boolean filters(JavaElementMatch match) {
378 return (match.getMatchRule() & (SearchPattern.R_FULL_MATCH)) == 0;
379 }
380 public String getName() {
381 return SearchMessages.MatchFilter_InexactFilter_name;
382 }
383 public String getActionLabel() {
384 return SearchMessages.MatchFilter_InexactFilter_actionLabel;
385 }
386 public String getDescription() {
387 return SearchMessages.MatchFilter_InexactFilter_description;
388 }
389 public String getID() {
390 return "filter_inexact"; }
392 }
393
394 abstract class ModifierFilter extends JavaMatchFilter {
395 public boolean isApplicable(JavaSearchQuery query) {
396 return true;
397 }
398 }
399
400 class NonPublicFilter extends ModifierFilter {
401 public boolean filters(JavaElementMatch match) {
402 Object element= match.getElement();
403 if (element instanceof IMember) {
404 try {
405 return ! JdtFlags.isPublic((IMember) element);
406 } catch (JavaModelException e) {
407 JavaPlugin.log(e);
408 }
409 }
410 return false;
411 }
412 public String getName() {
413 return SearchMessages.MatchFilter_NonPublicFilter_name;
414 }
415 public String getActionLabel() {
416 return SearchMessages.MatchFilter_NonPublicFilter_actionLabel;
417 }
418 public String getDescription() {
419 return SearchMessages.MatchFilter_NonPublicFilter_description;
420 }
421 public String getID() {
422 return "filter_non_public"; }
424 }
425
426 class StaticFilter extends ModifierFilter {
427 public boolean filters(JavaElementMatch match) {
428 Object element= match.getElement();
429 if (element instanceof IMember) {
430 try {
431 return JdtFlags.isStatic((IMember) element);
432 } catch (JavaModelException e) {
433 JavaPlugin.log(e);
434 }
435 }
436 return false;
437 }
438 public String getName() {
439 return SearchMessages.MatchFilter_StaticFilter_name;
440 }
441 public String getActionLabel() {
442 return SearchMessages.MatchFilter_StaticFilter_actionLabel;
443 }
444 public String getDescription() {
445 return SearchMessages.MatchFilter_StaticFilter_description;
446 }
447 public String getID() {
448 return "filter_static"; }
450 }
451
452 class NonStaticFilter extends ModifierFilter {
453 public boolean filters(JavaElementMatch match) {
454 Object element= match.getElement();
455 if (element instanceof IMember) {
456 try {
457 return ! JdtFlags.isStatic((IMember) element);
458 } catch (JavaModelException e) {
459 JavaPlugin.log(e);
460 }
461 }
462 return false;
463 }
464 public String getName() {
465 return SearchMessages.MatchFilter_NonStaticFilter_name;
466 }
467 public String getActionLabel() {
468 return SearchMessages.MatchFilter_NonStaticFilter_actionLabel;
469 }
470 public String getDescription() {
471 return SearchMessages.MatchFilter_NonStaticFilter_description;
472 }
473 public String getID() {
474 return "filter_non_static"; }
476 }
477
478 class DeprecatedFilter extends ModifierFilter {
479 public boolean filters(JavaElementMatch match) {
480 Object element= match.getElement();
481 if (element instanceof IMember) {
482 try {
483 return JdtFlags.isDeprecated((IMember) element);
484 } catch (JavaModelException e) {
485 JavaPlugin.log(e);
486 }
487 }
488 return false;
489 }
490 public String getName() {
491 return SearchMessages.MatchFilter_DeprecatedFilter_name;
492 }
493 public String getActionLabel() {
494 return SearchMessages.MatchFilter_DeprecatedFilter_actionLabel;
495 }
496 public String getDescription() {
497 return SearchMessages.MatchFilter_DeprecatedFilter_description;
498 }
499 public String getID() {
500 return "filter_deprecated"; }
502 }
503
504 class NonDeprecatedFilter extends ModifierFilter {
505 public boolean filters(JavaElementMatch match) {
506 Object element= match.getElement();
507 if (element instanceof IMember) {
508 try {
509 return !JdtFlags.isDeprecated((IMember) element);
510 } catch (JavaModelException e) {
511 JavaPlugin.log(e);
512 }
513 }
514 return false;
515 }
516 public String getName() {
517 return SearchMessages.MatchFilter_NonDeprecatedFilter_name;
518 }
519 public String getActionLabel() {
520 return SearchMessages.MatchFilter_NonDeprecatedFilter_actionLabel;
521 }
522 public String getDescription() {
523 return SearchMessages.MatchFilter_NonDeprecatedFilter_description;
524 }
525 public String getID() {
526 return "filter_non_deprecated"; }
528 }
529 |
Popular Tags |
Java API By Example, From Geeks To Geeks.