case-study/jdt-after/ui/org/eclipse/jdt/internal/ui/search/JavaMatchFilter.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2011 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  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.IImportDeclaration;
  21 import org.eclipse.jdt.core.IJavaElement;
  22 import org.eclipse.jdt.core.IMember;
  23 import org.eclipse.jdt.core.IMethod;
  24 import org.eclipse.jdt.core.IType;
  25 import org.eclipse.jdt.core.ITypeParameter;
  26 import org.eclipse.jdt.core.JavaModelException;
  27 import org.eclipse.jdt.core.search.SearchMatch;
  28 import org.eclipse.jdt.core.search.SearchPattern;
  29
  30 import org.eclipse.jdt.internal.corext.util.JdtFlags;
  31
  32 import org.eclipse.jdt.ui.search.QuerySpecification;
  33
  34 import org.eclipse.jdt.internal.ui.JavaPlugin;
  35
  36 abstract class JavaMatchFilter extends MatchFilter {
  37
  38         public abstract boolean filters(JavaElementMatch match);
  39
  40         /**
  41          * Returns whether this filter is applicable for this query.
  42          *
  43          * @param query the query
  44          * @return <code>true</code> if this match filter is applicable for the given query
  45          */
  46         public abstract boolean isApplicable(JavaSearchQuery query);
  47
  48         /* (non-Javadoc)
  49          * @see org.eclipse.search.ui.text.MatchFilter#filters(org.eclipse.search.ui.text.Match)
  50          */
  51         @Override
  52         public boolean filters(Match match) {
  53                 if (match instanceof JavaElementMatch) {
  54                         return filters((JavaElementMatch) match);
  55                 }
  56                 return false;
  57         }
  58
  59         private static final String SETTINGS_LAST_USED_FILTERS= "filters_last_used";  //$NON-NLS-1$
  60
  61         public static MatchFilter[] getLastUsedFilters() {
  62                 String string= JavaPlugin.getDefault().getDialogSettings().get(SETTINGS_LAST_USED_FILTERS);
  63                 if (string != null) {
  64                         return decodeFiltersString(string);
  65                 }
  66                 return getDefaultFilters();
  67         }
  68
  69         public static void setLastUsedFilters(MatchFilter[] filters) {
  70                 String encoded= encodeFilters(filters);
  71                 JavaPlugin.getDefault().getDialogSettings().put(SETTINGS_LAST_USED_FILTERS, encoded);
  72         }
  73
  74         public static MatchFilter[] getDefaultFilters() {
  75                 return new MatchFilter[] { IMPORT_FILTER };
  76         }
  77
  78         private static String encodeFilters(MatchFilter[] enabledFilters) {
  79                 StringBuffer buf= new StringBuffer();
  80                 for (int i= 0; i < enabledFilters.length; i++) {
  81                         MatchFilter matchFilter= enabledFilters[i];
  82                         buf.append(matchFilter.getID());
  83                         buf.append(';');
  84                 }
  85                 return buf.toString();
  86         }
  87
  88         private static JavaMatchFilter[] decodeFiltersString(String encodedString) {
  89                 StringTokenizer tokenizer= new StringTokenizer(encodedString, String.valueOf(';'));
  90                 HashSet<JavaMatchFilter> result= new HashSet<JavaMatchFilter>();
  91                 while (tokenizer.hasMoreTokens()) {
  92                         JavaMatchFilter curr= findMatchFilter(tokenizer.nextToken());
  93                         if (curr != null) {
  94                                 result.add(curr);
  95                         }
  96                 }
  97                 return result.toArray(new JavaMatchFilter[result.size()]);
  98         }
  99
 100         private static final JavaMatchFilter POTENTIAL_FILTER= new PotentialFilter();
 101         private static final JavaMatchFilter IMPORT_FILTER= new ImportFilter();
 102         private static final JavaMatchFilter JAVADOC_FILTER= new JavadocFilter();
 103         private static final JavaMatchFilter READ_FILTER= new ReadFilter();
 104         private static final JavaMatchFilter WRITE_FILTER= new WriteFilter();
 105
 106         private static final JavaMatchFilter POLYMORPHIC_FILTER= new PolymorphicFilter();
 107         private static final JavaMatchFilter INEXACT_FILTER= new InexactMatchFilter();
 108         private static final JavaMatchFilter ERASURE_FILTER= new ErasureMatchFilter();
 109
 110         private static final JavaMatchFilter NON_PUBLIC_FILTER= new NonPublicFilter();
 111         private static final JavaMatchFilter STATIC_FILTER= new StaticFilter();
 112         private static final JavaMatchFilter NON_STATIC_FILTER= new NonStaticFilter();
 113         private static final JavaMatchFilter DEPRECATED_FILTER= new DeprecatedFilter();
 114         private static final JavaMatchFilter NON_DEPRECATED_FILTER= new NonDeprecatedFilter();
 115
 116         private static final JavaMatchFilter[] ALL_FILTERS= new JavaMatchFilter[] {
 117                         POTENTIAL_FILTER,
 118                         IMPORT_FILTER,
 119                         JAVADOC_FILTER,
 120                         READ_FILTER,
 121                         WRITE_FILTER,
 122
 123             POLYMORPHIC_FILTER,
 124                         INEXACT_FILTER,
 125                         ERASURE_FILTER,
 126
 127                         NON_PUBLIC_FILTER,
 128                         STATIC_FILTER,
 129                         NON_STATIC_FILTER,
 130                         DEPRECATED_FILTER,
 131                         NON_DEPRECATED_FILTER
 132         };
 133
 134         public static JavaMatchFilter[] allFilters() {
 135                 return ALL_FILTERS;
 136         }
 137
 138         public static JavaMatchFilter[] allFilters(JavaSearchQuery query) {
 139                 ArrayList<JavaMatchFilter> res= new ArrayList<JavaMatchFilter>();
 140                 for (int i= 0; i < ALL_FILTERS.length; i++) {
 141                         JavaMatchFilter curr= ALL_FILTERS[i];
 142                         if (curr.isApplicable(query)) {
 143                                 res.add(curr);
 144                         }
 145                 }
 146                 return res.toArray(new JavaMatchFilter[res.size()]);
 147         }
 148
 149         private static JavaMatchFilter findMatchFilter(String id) {
 150                 for (int i= 0; i < ALL_FILTERS.length; i++) {
 151                         JavaMatchFilter matchFilter= ALL_FILTERS[i];
 152                         if (matchFilter.getID().equals(id))
 153                                 return matchFilter;
 154                 }
 155                 return null;
 156         }
 157 }
 158
 159 class PotentialFilter extends JavaMatchFilter {
 160         @Override
 161         public boolean filters(JavaElementMatch match) {
 162                 return match.getAccuracy() == SearchMatch.A_INACCURATE;
 163         }
 164
 165         @Override
 166         public String getName() {
 167                 return SearchMessages.MatchFilter_PotentialFilter_name;
 168         }
 169
 170         @Override
 171         public String getActionLabel() {
 172                 return SearchMessages.MatchFilter_PotentialFilter_actionLabel;
 173         }
 174
 175         @Override
 176         public String getDescription() {
 177                 return SearchMessages.MatchFilter_PotentialFilter_description;
 178         }
 179
 180         @Override
 181         public boolean isApplicable(JavaSearchQuery query) {
 182                 return true;
 183         }
 184
 185         @Override
 186         public String getID() {
 187                 return "filter_potential"; //$NON-NLS-1$
 188         }
 189 }
 190
 191 class ImportFilter extends JavaMatchFilter {
 192         @Override
 193         public boolean filters(JavaElementMatch match) {
 194                 return match.getElement() instanceof IImportDeclaration;
 195         }
 196
 197         @Override
 198         public String getName() {
 199                 return SearchMessages.MatchFilter_ImportFilter_name;
 200         }
 201
 202         @Override
 203         public String getActionLabel() {
 204                 return SearchMessages.MatchFilter_ImportFilter_actionLabel;
 205         }
 206
 207         @Override
 208         public String getDescription() {
 209                 return SearchMessages.MatchFilter_ImportFilter_description;
 210         }
 211
 212         @Override
 213         public boolean isApplicable(JavaSearchQuery query) {
 214                 QuerySpecification spec= query.getSpecification();
 215                 return spec.generated_7845922867642781666();
 216         }
 217
 218         @Override
 219         public String getID() {
 220                 return "filter_imports"; //$NON-NLS-1$
 221         }
 222 }
 223
 224 abstract class VariableFilter extends JavaMatchFilter {
 225         @Override
 226         public boolean isApplicable(JavaSearchQuery query) {
 227                 QuerySpecification spec= query.getSpecification();
 228                 return spec.generated_6462544269453860586();
 229         }
 230
 231 }
 232
 233 class WriteFilter extends VariableFilter {
 234         @Override
 235         public boolean filters(JavaElementMatch match) {
 236                 return match.generated_7731867086454870710();
 237         }
 238         @Override
 239         public String getName() {
 240                 return SearchMessages.MatchFilter_WriteFilter_name;
 241         }
 242         @Override
 243         public String getActionLabel() {
 244                 return SearchMessages.MatchFilter_WriteFilter_actionLabel;
 245         }
 246         @Override
 247         public String getDescription() {
 248                 return SearchMessages.MatchFilter_WriteFilter_description;
 249         }
 250         @Override
 251         public String getID() {
 252                 return "filter_writes"; //$NON-NLS-1$
 253         }
 254 }
 255
 256 class ReadFilter extends VariableFilter {
 257         @Override
 258         public boolean filters(JavaElementMatch match) {
 259                 return match.generated_6093278864195679574();
 260         }
 261         @Override
 262         public String getName() {
 263                 return SearchMessages.MatchFilter_ReadFilter_name;
 264         }
 265         @Override
 266         public String getActionLabel() {
 267                 return SearchMessages.MatchFilter_ReadFilter_actionLabel;
 268         }
 269         @Override
 270         public String getDescription() {
 271                 return SearchMessages.MatchFilter_ReadFilter_description;
 272         }
 273         @Override
 274         public String getID() {
 275                 return "filter_reads"; //$NON-NLS-1$
 276         }
 277 }
 278
 279 class JavadocFilter extends JavaMatchFilter {
 280         @Override
 281         public boolean filters(JavaElementMatch match) {
 282                 return match.isJavadoc();
 283         }
 284         @Override
 285         public String getName() {
 286                 return SearchMessages.MatchFilter_JavadocFilter_name;
 287         }
 288         @Override
 289         public String getActionLabel() {
 290                 return SearchMessages.MatchFilter_JavadocFilter_actionLabel;
 291         }
 292         @Override
 293         public String getDescription() {
 294                 return SearchMessages.MatchFilter_JavadocFilter_description;
 295         }
 296         @Override
 297         public boolean isApplicable(JavaSearchQuery query) {
 298                 return true;
 299         }
 300         @Override
 301         public String getID() {
 302                 return "filter_javadoc"; //$NON-NLS-1$
 303         }
 304 }
 305
 306 class PolymorphicFilter extends JavaMatchFilter {
 307     @Override
 308         public boolean filters(JavaElementMatch match) {
 309         return match.isSuperInvocation();
 310     }
 311
 312     @Override
 313         public String getName() {
 314         return SearchMessages.MatchFilter_PolymorphicFilter_name;
 315     }
 316
 317     @Override
 318         public String getActionLabel() {
 319         return SearchMessages.MatchFilter_PolymorphicFilter_actionLabel;
 320     }
 321
 322     @Override
 323         public String getDescription() {
 324         return SearchMessages.MatchFilter_PolymorphicFilter_description;
 325     }
 326
 327     @Override
 328         public boolean isApplicable(JavaSearchQuery query) {
 329         QuerySpecification spec= query.getSpecification();
 330         return spec.generated_7178017679938079001();
 331     }
 332
 333         @Override
 334         public String getID() {
 335         return "filter_polymorphic"; //$NON-NLS-1$
 336     }
 337 }
 338
 339 public abstract class GenericTypeFilter extends JavaMatchFilter {
 340         @Override
 341         public boolean isApplicable(JavaSearchQuery query) {
 342                 QuerySpecification spec= query.getSpecification();
 343                 return spec.generated_5909141912720500817();
 344         }
 345
 346         public static boolean isParameterizedElement(IJavaElement element) {
 347                 while (element != null) {
 348                         ITypeParameter[] typeParameters= null;
 349                         try {
 350                                 if (element instanceof IType) {
 351                                         typeParameters= ((IType)element).getTypeParameters();
 352                                 } else if (element instanceof IMethod) {
 353                                         typeParameters= ((IMethod)element).getTypeParameters();
 354                                 }
 355                         } catch (JavaModelException e) {
 356                                 return false;
 357                         }
 358                         if (typeParameters == null)
 359                                 return false;
 360
 361                         if (typeParameters.length > 0)
 362                                 return true;
 363
 364                         element= element.getParent();
 365                 }
 366                 return false;
 367         }
 368 }
 369
 370 class ErasureMatchFilter extends GenericTypeFilter {
 371         @Override
 372         public boolean filters(JavaElementMatch match) {
 373                 return (match.getMatchRule() & (SearchPattern.R_FULL_MATCH | SearchPattern.R_EQUIVALENT_MATCH)) == 0;
 374         }
 375         @Override
 376         public String getName() {
 377                 return SearchMessages.MatchFilter_ErasureFilter_name;
 378         }
 379         @Override
 380         public String getActionLabel() {
 381                 return SearchMessages.MatchFilter_ErasureFilter_actionLabel;
 382         }
 383         @Override
 384         public String getDescription() {
 385                 return SearchMessages.MatchFilter_ErasureFilter_description;
 386         }
 387         @Override
 388         public String getID() {
 389                 return "filter_erasure"; //$NON-NLS-1$
 390         }
 391 }
 392
 393 class InexactMatchFilter extends GenericTypeFilter {
 394         @Override
 395         public boolean filters(JavaElementMatch match) {
 396                 return (match.getMatchRule() & (SearchPattern.R_FULL_MATCH)) == 0;
 397         }
 398         @Override
 399         public String getName() {
 400                 return SearchMessages.MatchFilter_InexactFilter_name;
 401         }
 402         @Override
 403         public String getActionLabel() {
 404                 return SearchMessages.MatchFilter_InexactFilter_actionLabel;
 405         }
 406         @Override
 407         public String getDescription() {
 408                 return SearchMessages.MatchFilter_InexactFilter_description;
 409         }
 410         @Override
 411         public String getID() {
 412                 return "filter_inexact"; //$NON-NLS-1$
 413         }
 414 }
 415
 416 abstract class ModifierFilter extends JavaMatchFilter {
 417         @Override
 418         public boolean isApplicable(JavaSearchQuery query) {
 419                 return true;
 420         }
 421 }
 422
 423 class NonPublicFilter extends ModifierFilter {
 424         @Override
 425         public boolean filters(JavaElementMatch match) {
 426                 Object element= match.getElement();
 427                 if (element instanceof IMember) {
 428                         try {
 429                                 return ! JdtFlags.isPublic((IMember) element);
 430                         } catch (JavaModelException e) {
 431                                 JavaPlugin.log(e);
 432                         }
 433                 }
 434                 return false;
 435         }
 436         @Override
 437         public String getName() {
 438                 return SearchMessages.MatchFilter_NonPublicFilter_name;
 439         }
 440         @Override
 441         public String getActionLabel() {
 442                 return SearchMessages.MatchFilter_NonPublicFilter_actionLabel;
 443         }
 444         @Override
 445         public String getDescription() {
 446                 return SearchMessages.MatchFilter_NonPublicFilter_description;
 447         }
 448         @Override
 449         public String getID() {
 450                 return "filter_non_public"; //$NON-NLS-1$
 451         }
 452 }
 453
 454 class StaticFilter extends ModifierFilter {
 455         @Override
 456         public boolean filters(JavaElementMatch match) {
 457                 Object element= match.getElement();
 458                 if (element instanceof IMember) {
 459                         try {
 460                                 return JdtFlags.isStatic((IMember) element);
 461                         } catch (JavaModelException e) {
 462                                 JavaPlugin.log(e);
 463                         }
 464                 }
 465                 return false;
 466         }
 467         @Override
 468         public String getName() {
 469                 return SearchMessages.MatchFilter_StaticFilter_name;
 470         }
 471         @Override
 472         public String getActionLabel() {
 473                 return SearchMessages.MatchFilter_StaticFilter_actionLabel;
 474         }
 475         @Override
 476         public String getDescription() {
 477                 return SearchMessages.MatchFilter_StaticFilter_description;
 478         }
 479         @Override
 480         public String getID() {
 481                 return  "filter_static"; //$NON-NLS-1$
 482         }
 483 }
 484
 485 class NonStaticFilter extends ModifierFilter {
 486         @Override
 487         public boolean filters(JavaElementMatch match) {
 488                 Object element= match.getElement();
 489                 if (element instanceof IMember) {
 490                         try {
 491                                 return ! JdtFlags.isStatic((IMember) element);
 492                         } catch (JavaModelException e) {
 493                                 JavaPlugin.log(e);
 494                         }
 495                 }
 496                 return false;
 497         }
 498         @Override
 499         public String getName() {
 500                 return SearchMessages.MatchFilter_NonStaticFilter_name;
 501         }
 502         @Override
 503         public String getActionLabel() {
 504                 return SearchMessages.MatchFilter_NonStaticFilter_actionLabel;
 505         }
 506         @Override
 507         public String getDescription() {
 508                 return SearchMessages.MatchFilter_NonStaticFilter_description;
 509         }
 510         @Override
 511         public String getID() {
 512                 return  "filter_non_static"; //$NON-NLS-1$
 513         }
 514 }
 515
 516 class DeprecatedFilter extends ModifierFilter {
 517         @Override
 518         public boolean filters(JavaElementMatch match) {
 519                 Object element= match.getElement();
 520                 if (element instanceof IMember) {
 521                         try {
 522                                 return JdtFlags.isDeprecated((IMember) element);
 523                         } catch (JavaModelException e) {
 524                                 JavaPlugin.log(e);
 525                         }
 526                 }
 527                 return false;
 528         }
 529         @Override
 530         public String getName() {
 531                 return SearchMessages.MatchFilter_DeprecatedFilter_name;
 532         }
 533         @Override
 534         public String getActionLabel() {
 535                 return SearchMessages.MatchFilter_DeprecatedFilter_actionLabel;
 536         }
 537         @Override
 538         public String getDescription() {
 539                 return SearchMessages.MatchFilter_DeprecatedFilter_description;
 540         }
 541         @Override
 542         public String getID() {
 543                 return  "filter_deprecated"; //$NON-NLS-1$
 544         }
 545 }
 546
 547 class NonDeprecatedFilter extends ModifierFilter {
 548         @Override
 549         public boolean filters(JavaElementMatch match) {
 550                 Object element= match.getElement();
 551                 if (element instanceof IMember) {
 552                         try {
 553                                 return !JdtFlags.isDeprecated((IMember) element);
 554                         } catch (JavaModelException e) {
 555                                 JavaPlugin.log(e);
 556                         }
 557                 }
 558                 return false;
 559         }
 560         @Override
 561         public String getName() {
 562                 return SearchMessages.MatchFilter_NonDeprecatedFilter_name;
 563         }
 564         @Override
 565         public String getActionLabel() {
 566                 return SearchMessages.MatchFilter_NonDeprecatedFilter_actionLabel;
 567         }
 568         @Override
 569         public String getDescription() {
 570                 return SearchMessages.MatchFilter_NonDeprecatedFilter_description;
 571         }
 572         @Override
 573         public String getID() {
 574                 return  "filter_non_deprecated"; //$NON-NLS-1$
 575         }
 576 }