/*******************************************************************************
* Copyright (c) 2000, 2012 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* Stephan Herrmann - Contributions for bug 215139 and bug 295894
*******************************************************************************/
package org.eclipse.che.jdt.core.search;
import org.eclipse.che.jdt.internal.core.JavaProject;
import org.eclipse.che.jdt.internal.core.search.BasicSearchEngine;
import org.eclipse.che.jdt.internal.core.search.IRestrictedAccessTypeRequestor;
import org.eclipse.che.jdt.internal.core.search.TypeNameMatchRequestorWrapper;
import org.eclipse.che.jdt.internal.core.search.TypeNameRequestorWrapper;
import org.eclipse.che.jdt.internal.core.search.indexing.IndexManager;
import org.eclipse.che.jdt.internal.core.search.matching.DeclarationOfAccessedFieldsPattern;
import org.eclipse.che.jdt.internal.core.search.matching.DeclarationOfReferencedMethodsPattern;
import org.eclipse.che.jdt.internal.core.search.matching.DeclarationOfReferencedTypesPattern;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.Flags;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.WorkingCopyOwner;
import org.eclipse.jdt.internal.compiler.env.AccessRestriction;
/**
* A {@link SearchEngine} searches for Java elements following a search pattern.
* The search can be limited to a search scope.
* <p>
* Various search patterns can be created using the factory methods
* {@link SearchPattern#createPattern(String, int, int, int)}, {@link SearchPattern#createPattern(org.eclipse.jdt.core.IJavaElement, int)},
* {@link SearchPattern#createOrPattern(SearchPattern, SearchPattern)}.
* </p>
* <p>For example, one can search for references to a method in the hierarchy of a type,
* or one can search for the declarations of types starting with "Abstract" in a project.
* </p>
* <p>
* This class may be instantiated.
* </p>
*
* @noextend This class is not intended to be subclassed by clients.
*/
public class SearchEngine {
private IndexManager indexManager;
/**
* Internal adapter class.
*
* @deprecated marking deprecated as it uses deprecated ISearchPattern
*/
static class SearchPatternAdapter implements ISearchPattern {
SearchPattern pattern;
SearchPatternAdapter(SearchPattern pattern) {
this.pattern = pattern;
}
}
/**
* Internal adapter class.
*
* @deprecated marking deprecated as it uses deprecated IJavaSearchResultCollector
*/
static class ResultCollectorAdapter extends SearchRequestor {
IJavaSearchResultCollector resultCollector;
ResultCollectorAdapter(IJavaSearchResultCollector resultCollector) {
this.resultCollector = resultCollector;
}
/**
* @see SearchRequestor#acceptSearchMatch(SearchMatch)
*/
public void acceptSearchMatch(SearchMatch match) throws CoreException {
this.resultCollector.accept(
match.getResource(),
match.getOffset(),
match.getOffset() + match.getLength(),
(IJavaElement)match.getElement(),
match.getAccuracy()
);
}
/**
* @see SearchRequestor#beginReporting()
*/
public void beginReporting() {
this.resultCollector.aboutToStart();
}
/**
* @see SearchRequestor#endReporting()
*/
public void endReporting() {
this.resultCollector.done();
}
}
/**
* Internal adapter class.
*
* @deprecated marking deprecated as it uses deprecated ITypeNameRequestor
*/
static class TypeNameRequestorAdapter implements IRestrictedAccessTypeRequestor {
ITypeNameRequestor nameRequestor;
TypeNameRequestorAdapter(ITypeNameRequestor requestor) {
this.nameRequestor = requestor;
}
public void acceptType(int modifiers, char[] packageName, char[] simpleTypeName, char[][] enclosingTypeNames, String path,
AccessRestriction access) {
if (Flags.isInterface(modifiers)) {
this.nameRequestor.acceptInterface(packageName, simpleTypeName, enclosingTypeNames, path);
} else {
this.nameRequestor.acceptClass(packageName, simpleTypeName, enclosingTypeNames, path);
}
}
}
// Search engine now uses basic engine functionalities
private BasicSearchEngine basicEngine;
/**
* Creates a new search engine.
*/
public SearchEngine(IndexManager indexManager, JavaProject javaProject) {
this.indexManager = indexManager;
this.basicEngine = new BasicSearchEngine(indexManager, javaProject);
}
// /**
// * Creates a new search engine with a list of working copies that will take precedence over
// * their original compilation units in the subsequent search operations.
// * <p>
// * Note that passing an empty working copy will be as if the original compilation
// * unit had been deleted.</p>
// * <p>
// * Since 3.0 the given working copies take precedence over primary working copies (if any).
// *
// * @param workingCopies the working copies that take precedence over their original compilation units
// * @since 3.0
// */
// public SearchEngine(ICompilationUnit[] workingCopies) {
// this.basicEngine = new BasicSearchEngine(workingCopies);
// }
//
// /**
// * Creates a new search engine with a list of working copies that will take precedence over
// * their original compilation units in the subsequent search operations.
// * <p>
// * Note that passing an empty working copy will be as if the original compilation
// * unit had been deleted.</p>
// * <p>
// * Since 3.0 the given working copies take precedence over primary working copies (if any).
// *
// * @param workingCopies the working copies that take precedence over their original compilation units
// * @since 2.0
// * @deprecated Use {@link #SearchEngine(org.eclipse.jdt.core.ICompilationUnit[])} instead.
// */
// public SearchEngine(IWorkingCopy[] workingCopies) {
// int length = workingCopies.length;
// ICompilationUnit[] units = new ICompilationUnit[length];
// System.arraycopy(workingCopies, 0, units, 0, length);
// this.basicEngine = new BasicSearchEngine(units);
// }
//
// /**
// * Creates a new search engine with the given working copy owner.
// * The working copies owned by this owner will take precedence over
// * the primary compilation units in the subsequent search operations.
// *
// * @param workingCopyOwner the owner of the working copies that take precedence over their original compilation units
// * @since 3.0
// */
// public SearchEngine(WorkingCopyOwner workingCopyOwner) {
// this.basicEngine = new BasicSearchEngine(workingCopyOwner);
// }
/**
* Returns a Java search scope limited to the hierarchy of the given type.
* The Java elements resulting from a search with this scope will
* be types in this hierarchy, or members of the types in this hierarchy.
*
* @param type
* the focus of the hierarchy scope
* @return a new hierarchy scope
* @throws org.eclipse.jdt.core.JavaModelException
* if the hierarchy could not be computed on the given type
*/
public static IJavaSearchScope createHierarchyScope(IType type) throws JavaModelException {
return BasicSearchEngine.createHierarchyScope(type);
}
/**
* Returns a Java search scope limited to the hierarchy of the given type.
* When the hierarchy is computed, the types defined in the working copies owned
* by the given owner take precedence over the original compilation units.
* The Java elements resulting from a search with this scope will
* be types in this hierarchy, or members of the types in this hierarchy.
*
* @param type
* the focus of the hierarchy scope
* @param owner
* the owner of working copies that take precedence over original compilation units
* @return a new hierarchy scope
* @throws org.eclipse.jdt.core.JavaModelException
* if the hierarchy could not be computed on the given type
* @since 3.0
*/
public static IJavaSearchScope createHierarchyScope(IType type, WorkingCopyOwner owner) throws JavaModelException {
return BasicSearchEngine.createHierarchyScope(type, owner);
}
/**
* Returns a Java search scope limited to the hierarchy of the given type and to a given project.
* The Java elements resulting from a search with this scope will be types in this hierarchy.
* <p>
* Unlike the <code>createHierarchyScope</code> methods, this method creates <em>strict</em>
* scopes that only contain types that actually span the hierarchy of the focus
* type, but do not include additional enclosing or member types.
* </p>
* <p>
* By default, hierarchy scopes include all direct and indirect supertypes and subtypes of the
* focus type. This method, however, allows to restrict the hierarchy to true subtypes,
* and exclude supertypes. Also, inclusion of the focus type itself is controlled by a parameter.
* </p>
*
* @param project
* the project to which to constrain the search, or <code>null</code> if
* search should consider all types in the workspace
* @param type
* the focus of the hierarchy scope
* @param onlySubtypes
* if <code>true</code> only subtypes of <code>type</code> are considered
* @param includeFocusType
* if true the focus type <code>type</code> is included in the resulting scope,
* otherwise it is excluded
* @param owner
* the owner of working copies that take precedence over original compilation units,
* or <code>null</code> if the primary working copy owner should be used
* @return a new hierarchy scope
* @throws org.eclipse.jdt.core.JavaModelException
* if the hierarchy could not be computed on the given type
* @since 3.6
*/
public static IJavaSearchScope createStrictHierarchyScope(IJavaProject project, IType type, boolean onlySubtypes,
boolean includeFocusType, WorkingCopyOwner owner) throws
JavaModelException {
return BasicSearchEngine.createStrictHierarchyScope(project, type, onlySubtypes, includeFocusType, owner);
}
/**
* Returns a Java search scope limited to the given resources.
* The Java elements resulting from a search with this scope will
* have their underlying resource included in or equals to one of the given
* resources.
* <p>
* Resources must not overlap, for example, one cannot include a folder and its children.
* </p>
*
* @param resources
* the resources the scope is limited to
* @return a new Java search scope
* @deprecated Use {@link #createJavaSearchScope(org.eclipse.jdt.core.IJavaElement[])} instead.
*/
public static IJavaSearchScope createJavaSearchScope(IResource[] resources) {
int length = resources.length;
IJavaElement[] elements = new IJavaElement[length];
for (int i = 0; i < length; i++) {
elements[i] = JavaCore.create(resources[i]);
}
return createJavaSearchScope(elements);
}
/**
* Returns a Java search scope limited to the given Java elements.
* The Java elements resulting from a search with this scope will
* be children of the given elements.
* <p>
* If an element is an {@link org.eclipse.jdt.core.IJavaProject}, then the project's source folders,
* its jars (external and internal) and its referenced projects (with their source
* folders and jars, recursively) will be included.</p>
* <p>If an element is an {@link org.eclipse.jdt.core.IPackageFragmentRoot}, then only the package fragments of
* this package fragment root will be included.</p>
* <p>If an element is an {@link org.eclipse.jdt.core.IPackageFragment}, then only the compilation unit and class
* files of this package fragment will be included. Subpackages will NOT be
* included.</p>
* <p/>
* <p>In other words, this is equivalent to using SearchEngine.createJavaSearchScope(elements, true).</p>
*
* @param elements
* the Java elements the scope is limited to
* @return a new Java search scope
* @since 2.0
*/
public static IJavaSearchScope createJavaSearchScope(IJavaElement[] elements) {
return BasicSearchEngine.createJavaSearchScope(elements);
}
/**
* Returns a Java search scope limited to the given Java elements.
* The Java elements resulting from a search with this scope will
* be children of the given elements.
* <p/>
* <p>If an element is an {@link org.eclipse.jdt.core.IJavaProject}, then the project's source folders,
* its jars (external and internal) and - if specified - its referenced projects
* (with their source folders and jars, recursively) will be included.</p>
* <p>If an element is an {@link org.eclipse.jdt.core.IPackageFragmentRoot}, then only the package fragments of
* this package fragment root will be included.</p>
* <p>If an element is an {@link org.eclipse.jdt.core.IPackageFragment}, then only the compilation unit and class
* files of this package fragment will be included. Subpackages will NOT be
* included.</p>
*
* @param elements
* the Java elements the scope is limited to
* @param includeReferencedProjects
* a flag indicating if referenced projects must be
* recursively included
* @return a new Java search scope
* @since 2.0
*/
public static IJavaSearchScope createJavaSearchScope(IJavaElement[] elements, boolean includeReferencedProjects) {
return BasicSearchEngine.createJavaSearchScope(elements, includeReferencedProjects);
}
/**
* Returns a Java search scope limited to the given Java elements.
* The Java elements resulting from a search with this scope will
* be children of the given elements.
* <p/>
* <p>If an element is an IJavaProject, then it includes:</p>
* <ul>
* <li>its source folders if {@link IJavaSearchScope#SOURCES} is specified,</li>
* <li>its application libraries (internal and external jars, class folders that are on the raw classpath,
* or the ones that are coming from a classpath path variable,
* or the ones that are coming from a classpath container with the K_APPLICATION kind)
* if {@link IJavaSearchScope#APPLICATION_LIBRARIES} is specified</li>
* <li>its system libraries (internal and external jars, class folders that are coming from an
* IClasspathContainer with the K_SYSTEM kind)
* if {@link IJavaSearchScope#SYSTEM_LIBRARIES} is specified</li>
* <li>its referenced projects (with their source folders and jars, recursively)
* if {@link IJavaSearchScope#REFERENCED_PROJECTS} is specified.</li>
* </ul>
* <p>If an element is an {@link org.eclipse.jdt.core.IPackageFragmentRoot}, then only the package fragments of
* this package fragment root will be included.</p>
* <p>If an element is an {@link org.eclipse.jdt.core.IPackageFragment}, then only the compilation unit and class
* files of this package fragment will be included. Subpackages will NOT be
* included.</p>
*
* @param elements
* the Java elements the scope is limited to
* @param includeMask
* the bit-wise OR of all include types of interest
* @return a new Java search scope
* @see IJavaSearchScope#SOURCES
* @see IJavaSearchScope#APPLICATION_LIBRARIES
* @see IJavaSearchScope#SYSTEM_LIBRARIES
* @see IJavaSearchScope#REFERENCED_PROJECTS
* @since 3.0
*/
public static IJavaSearchScope createJavaSearchScope(IJavaElement[] elements, int includeMask) {
return BasicSearchEngine.createJavaSearchScope(elements, includeMask);
}
/**
* Returns a search pattern that combines the given two patterns into a "or" pattern.
* The search result will match either the left pattern or the right pattern.
*
* @param leftPattern
* the left pattern
* @param rightPattern
* the right pattern
* @return a "or" pattern
* @deprecated Use {@link org.eclipse.jdt.core.search.SearchPattern#createOrPattern(org.eclipse.jdt.core.search.SearchPattern,
* org.eclipse.jdt.core.search.SearchPattern)} instead.
*/
public static ISearchPattern createOrSearchPattern(ISearchPattern leftPattern, ISearchPattern rightPattern) {
SearchPattern left = ((SearchPatternAdapter)leftPattern).pattern;
SearchPattern right = ((SearchPatternAdapter)rightPattern).pattern;
SearchPattern pattern = SearchPattern.createOrPattern(left, right);
return new SearchPatternAdapter(pattern);
}
/**
* Returns a search pattern based on a given string pattern. The string patterns support '*' wild-cards.
* The remaining parameters are used to narrow down the type of expected results.
* <p/>
* <br>
* Examples:
* <ul>
* <li>search for case insensitive references to <code>Object</code>:
* <code>createSearchPattern("Object", TYPE, REFERENCES, false);</code></li>
* <li>search for case sensitive references to exact <code>Object()</code> constructor:
* <code>createSearchPattern("java.lang.Object()", CONSTRUCTOR, REFERENCES, true);</code></li>
* <li>search for implementers of <code>java.lang.Runnable</code>:
* <code>createSearchPattern("java.lang.Runnable", TYPE, IMPLEMENTORS, true);</code></li>
* </ul>
*
* @param stringPattern
* the given pattern
* @param searchFor
* determines the nature of the searched elements
* <ul>
* <li>{@link org.eclipse.jdt.core.search.IJavaSearchConstants#CLASS}: only look for classes</li>
* <li>{@link org.eclipse.jdt.core.search.IJavaSearchConstants#INTERFACE}: only look for interfaces</li>
* <li>{@link org.eclipse.jdt.core.search.IJavaSearchConstants#TYPE}: look for both classes and interfaces</li>
* <li>{@link org.eclipse.jdt.core.search.IJavaSearchConstants#FIELD}: look for fields</li>
* <li>{@link org.eclipse.jdt.core.search.IJavaSearchConstants#METHOD}: look for methods</li>
* <li>{@link org.eclipse.jdt.core.search.IJavaSearchConstants#CONSTRUCTOR}: look for constructors</li>
* <li>{@link org.eclipse.jdt.core.search.IJavaSearchConstants#PACKAGE}: look for packages</li>
* </ul>
* @param limitTo
* determines the nature of the expected matches
* <ul>
* <li>{@link org.eclipse.jdt.core.search.IJavaSearchConstants#DECLARATIONS}: will search declarations matching with the
* corresponding
* element. In case the element is a method, declarations of matching methods in subtypes will also
* be found, allowing to find declarations of abstract methods, etc.</li>
* <p/>
* <li>{@link org.eclipse.jdt.core.search.IJavaSearchConstants#REFERENCES}: will search references to the given element.</li>
* <p/>
* <li>{@link org.eclipse.jdt.core.search.IJavaSearchConstants#ALL_OCCURRENCES}: will search for either declarations or
* references as specified
* above.</li>
* <p/>
* <li>{@link org.eclipse.jdt.core.search.IJavaSearchConstants#IMPLEMENTORS}: for types, will find all types
* which directly implement/extend a given interface.
* Note that types may be only classes or only interfaces if {@link org.eclipse.jdt.core.search
* .IJavaSearchConstants#CLASS } or
* {@link org.eclipse.jdt.core.search.IJavaSearchConstants#INTERFACE} is respectively used instead of {@link
* org.eclipse.jdt.core.search.IJavaSearchConstants#TYPE}.
* </li>
* </ul>
* @param isCaseSensitive
* indicates whether the search is case sensitive or not.
* @return a search pattern on the given string pattern, or <code>null</code> if the string pattern is ill-formed.
* @deprecated Use {@link org.eclipse.jdt.core.search.SearchPattern#createPattern(String, int, int, int)} instead.
*/
public static ISearchPattern createSearchPattern(String stringPattern, int searchFor, int limitTo, boolean isCaseSensitive) {
int matchMode = stringPattern.indexOf('*') != -1 || stringPattern.indexOf('?') != -1
? SearchPattern.R_PATTERN_MATCH
: SearchPattern.R_EXACT_MATCH;
int matchRule = isCaseSensitive ? matchMode | SearchPattern.R_CASE_SENSITIVE : matchMode;
return new SearchPatternAdapter(SearchPattern.createPattern(stringPattern, searchFor, limitTo, matchRule));
}
/**
* Returns a search pattern based on a given Java element.
* The pattern is used to trigger the appropriate search, and can be parameterized as follows:
*
* @param element
* the Java element the search pattern is based on
* @param limitTo
* determines the nature of the expected matches
* <ul>
* <li>{@link org.eclipse.jdt.core.search.IJavaSearchConstants#DECLARATIONS}: will search declarations matching with the
* corresponding
* element. In case the element is a method, declarations of matching methods in subtypes will also
* be found, allowing to find declarations of abstract methods, etc.</li>
* <p/>
* <li>{@link org.eclipse.jdt.core.search.IJavaSearchConstants#REFERENCES}: will search references to the given element.</li>
* <p/>
* <li>{@link org.eclipse.jdt.core.search.IJavaSearchConstants#ALL_OCCURRENCES}: will search for either declarations or
* references as specified
* above.</li>
* <p/>
* <li>{@link org.eclipse.jdt.core.search.IJavaSearchConstants#IMPLEMENTORS}: for types, will find all types
* which directly implement/extend a given interface.</li>
* </ul>
* @return a search pattern for a Java element or <code>null</code> if the given element is ill-formed
* @deprecated Use {@link org.eclipse.jdt.core.search.SearchPattern#createPattern(org.eclipse.jdt.core.IJavaElement, int)} instead.
*/
public static ISearchPattern createSearchPattern(IJavaElement element, int limitTo) {
return new SearchPatternAdapter(SearchPattern.createPattern(element, limitTo));
}
/**
* Create a type name match on a given type with specific modifiers.
*
* @param type
* The java model handle of the type
* @param modifiers
* Modifiers of the type
* @return A non-null match on the given type.
* @since 3.3
*/
public static TypeNameMatch createTypeNameMatch(IType type, int modifiers) {
return BasicSearchEngine.createTypeNameMatch(type, modifiers);
}
/**
* Returns a Java search scope with the workspace as the only limit.
*
* @return a new workspace scope
*/
public static IJavaSearchScope createWorkspaceScope() {
return BasicSearchEngine.createWorkspaceScope();
}
/**
* Returns a new default Java search participant.
*
* @return a new default Java search participant
* @since 3.0
*/
public static SearchParticipant getDefaultSearchParticipant(IndexManager indexManager, JavaProject javaProject) {
return BasicSearchEngine.getDefaultSearchParticipant(indexManager, javaProject);
}
/**
* Searches for the Java element determined by the given signature. The signature
* can be incomplete. For example, a call like
* <code>search(ws, "run()", METHOD,REFERENCES, col)</code>
* searches for all references to the method <code>run</code>.
* <p/>
* Note that by default the pattern will be case insensitive. For specifying case s
* sensitive search, use <code>search(workspace, createSearchPattern(patternString, searchFor, limitTo, true), scope,
* resultCollector);</code>
*
* @param workspace
* the workspace
* @param patternString
* the pattern to be searched for
* @param searchFor
* a hint what kind of Java element the string pattern represents.
* Look into {@link IJavaSearchConstants} for valid values
* @param limitTo
* one of the following values:
* <ul>
* <li>{@link IJavaSearchConstants#DECLARATIONS}: search
* for declarations only </li>
* <li>{@link IJavaSearchConstants#REFERENCES}: search
* for all references </li>
* <li>{@link IJavaSearchConstants#ALL_OCCURRENCES}: search
* for both declarations and all references </li>
* <li>{@link IJavaSearchConstants#IMPLEMENTORS}: for types, will find all types
* which directly implement/extend a given interface.<br>
* Note that types may be only classes or only interfaces if respectively {@link IJavaSearchConstants#CLASS} or
* {@link IJavaSearchConstants#INTERFACE} is used for searchFor parameter instead of {@link IJavaSearchConstants#TYPE}.
* </li>
* </ul>
* @param scope
* the search result has to be limited to the given scope
* @param resultCollector
* a callback object to which each match is reported
* @throws org.eclipse.jdt.core.JavaModelException
* if the search failed. Reasons include:
* <ul>
* <li>the classpath is incorrectly set</li>
* </ul>
* @deprecated Use {@link #search(SearchPattern, SearchParticipant[], IJavaSearchScope, SearchRequestor, org.eclipse.core.runtime
* .IProgressMonitor)} instead.
*/
public void search(IWorkspace workspace, String patternString, int searchFor, int limitTo, IJavaSearchScope scope,
IJavaSearchResultCollector resultCollector) throws
JavaModelException {
// try {
// int matchMode = patternString.indexOf('*') != -1 || patternString.indexOf('?') != -1
// ? SearchPattern.R_PATTERN_MATCH
// : SearchPattern.R_EXACT_MATCH;
// search(
// SearchPattern.createPattern(patternString, searchFor, limitTo, matchMode | SearchPattern.R_CASE_SENSITIVE),
// new SearchParticipant[] {getDefaultSearchParticipant(indexManager, )},
// scope,
// new ResultCollectorAdapter(resultCollector),
// resultCollector.getProgressMonitor());
// } catch (CoreException e) {
// if (e instanceof JavaModelException)
// throw (JavaModelException) e;
// throw new JavaModelException(e);
// }
throw new UnsupportedOperationException();
}
/**
* Searches for the given Java element.
*
* @param workspace
* the workspace
* @param element
* the Java element to be searched for
* @param limitTo
* one of the following values:
* <ul>
* <li>{@link IJavaSearchConstants#DECLARATIONS}: search
* for declarations only </li>
* <li>{@link IJavaSearchConstants#REFERENCES}: search
* for all references </li>
* <li>{@link IJavaSearchConstants#ALL_OCCURRENCES}: search
* for both declarations and all references </li>
* <li>{@link IJavaSearchConstants#IMPLEMENTORS}: for types, will find all types
* which directly implement/extend a given interface.</li>
* </ul>
* @param scope
* the search result has to be limited to the given scope
* @param resultCollector
* a callback object to which each match is reported
* @throws org.eclipse.jdt.core.JavaModelException
* if the search failed. Reasons include:
* <ul>
* <li>the element doesn't exist</li>
* <li>the classpath is incorrectly set</li>
* </ul>
* @deprecated Use {@link #search(SearchPattern, SearchParticipant[], IJavaSearchScope, SearchRequestor,
* org.eclipse.core.runtime.IProgressMonitor)} instead.
*/
public void search(IWorkspace workspace, IJavaElement element, int limitTo, IJavaSearchScope scope,
IJavaSearchResultCollector resultCollector) throws
JavaModelException {
search(workspace, createSearchPattern(element, limitTo), scope, resultCollector);
}
/**
* Searches for matches of a given search pattern. Search patterns can be created using helper
* methods (from a String pattern or a Java element) and encapsulate the description of what is
* being searched (for example, search method declarations in a case sensitive way).
*
* @param workspace
* the workspace
* @param searchPattern
* the pattern to be searched for
* @param scope
* the search result has to be limited to the given scope
* @param resultCollector
* a callback object to which each match is reported
* @throws org.eclipse.jdt.core.JavaModelException
* if the search failed. Reasons include:
* <ul>
* <li>the classpath is incorrectly set</li>
* </ul>
* @deprecated Use {@link #search(SearchPattern, SearchParticipant[], IJavaSearchScope, SearchRequestor, org.eclipse.core.runtime
* .IProgressMonitor)} instead.
*/
public void search(IWorkspace workspace, ISearchPattern searchPattern, IJavaSearchScope scope,
IJavaSearchResultCollector resultCollector) throws
JavaModelException {
// try {
// search(
// ((SearchPatternAdapter)searchPattern).pattern,
// new SearchParticipant[] {getDefaultSearchParticipant(indexManager)},
// scope,
// new ResultCollectorAdapter(resultCollector),
// resultCollector.getProgressMonitor());
// } catch (CoreException e) {
// if (e instanceof JavaModelException)
// throw (JavaModelException) e;
// throw new JavaModelException(e);
// }
throw new UnsupportedOperationException();
}
/**
* Searches for matches of a given search pattern. Search patterns can be created using helper
* methods (from a String pattern or a Java element) and encapsulate the description of what is
* being searched (for example, search method declarations in a case sensitive way).
*
* @param pattern
* the pattern to search
* @param participants
* the particpants in the search
* @param scope
* the search scope
* @param requestor
* the requestor to report the matches to
* @param monitor
* the progress monitor used to report progress
* @throws org.eclipse.core.runtime.CoreException
* if the search failed. Reasons include:
* <ul>
* <li>the classpath is incorrectly set</li>
* </ul>
* @since 3.0
*/
public void search(SearchPattern pattern, SearchParticipant[] participants, IJavaSearchScope scope, SearchRequestor requestor,
IProgressMonitor monitor) throws
CoreException {
this.basicEngine.search(pattern, participants, scope, requestor, monitor);
}
/**
* Searches for all top-level types and member types in the given scope.
* The search can be selecting specific types (given a package exact full name or
* a type name with specific match mode).
*
* @param packageExactName
* the exact package full name of the searched types.<br>
* If you want to use a prefix or a wild-carded string for package, you need to use
* {@link #searchAllTypeNames(char[], int, char[], int, int, IJavaSearchScope, TypeNameRequestor, int,
* org.eclipse.core.runtime.IProgressMonitor)}
* method instead. May be <code>null</code>, then any package name is accepted.
* @param typeName
* the dot-separated qualified name of the searched type (the qualification include
* the enclosing types if the searched type is a member type), or a prefix
* for this type, or a wild-carded string for this type.
* May be <code>null</code>, then any type name is accepted.
* @param matchRule
* type name match rule one of
* <ul>
* <li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type
* name are the full names of the searched types.</li>
* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type
* name are prefixes of the names of the searched types.</li>
* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and
* type name contain wild-cards.</li>
* <li>{@link SearchPattern#R_CAMELCASE_MATCH} if the type name is a
* camel case of the searched types name.</li>
* <li>{@link SearchPattern#R_CAMELCASE_SAME_PART_COUNT_MATCH}
* if the type name is a camel case with same part count of the searched
* types name.</li>
* </ul>
* combined with {@link SearchPattern#R_CASE_SENSITIVE},
* e.g. {@link SearchPattern#R_EXACT_MATCH} | {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is
* requested,
* or {@link SearchPattern#R_PREFIX_MATCH} if a prefix non case sensitive match is requested.
* @param searchFor
* determines the nature of the searched elements
* <ul>
* <li>{@link IJavaSearchConstants#CLASS}: only look for classes</li>
* <li>{@link IJavaSearchConstants#INTERFACE}: only look for interfaces</li>
* <li>{@link IJavaSearchConstants#ENUM}: only look for enumeration</li>
* <li>{@link IJavaSearchConstants#ANNOTATION_TYPE}: only look for annotation type</li>
* <li>{@link IJavaSearchConstants#CLASS_AND_ENUM}: only look for classes and enumerations</li>
* <li>{@link IJavaSearchConstants#CLASS_AND_INTERFACE}: only look for classes and interfaces</li>
* <li>{@link IJavaSearchConstants#TYPE}: look for all types (i.e. classes, interfaces, enum and annotation types)</li>
* </ul>
* @param scope
* the scope to search in
* @param nameRequestor
* the requestor that collects the results of the search
* @param waitingPolicy
* one of
* <ul>
* <li>{@link IJavaSearchConstants#FORCE_IMMEDIATE_SEARCH} if the search should start immediately</li>
* <li>{@link IJavaSearchConstants#CANCEL_IF_NOT_READY_TO_SEARCH} if the search should be cancelled if the
* underlying indexer has not finished indexing the workspace</li>
* <li>{@link IJavaSearchConstants#WAIT_UNTIL_READY_TO_SEARCH} if the search should wait for the
* underlying indexer to finish indexing the workspace</li>
* </ul>
* @param progressMonitor
* the progress monitor to report progress to, or <code>null</code> if no progress
* monitor is provided
* @throws org.eclipse.jdt.core.JavaModelException
* if the search failed. Reasons include:
* <ul>
* <li>the classpath is incorrectly set</li>
* </ul>
* @since 3.1
* @deprecated Use {@link #searchAllTypeNames(char[], int, char[], int, int, IJavaSearchScope, TypeNameRequestor, int,
* org.eclipse.core.runtime.IProgressMonitor)}
* instead
*/
public void searchAllTypeNames(
final char[] packageExactName,
final char[] typeName,
final int matchRule,
int searchFor,
IJavaSearchScope scope,
final TypeNameRequestor nameRequestor,
int waitingPolicy,
IProgressMonitor progressMonitor) throws JavaModelException {
searchAllTypeNames(packageExactName, SearchPattern.R_EXACT_MATCH, typeName, matchRule, searchFor, scope, nameRequestor,
waitingPolicy, progressMonitor);
}
/**
* Searches for all top-level types and member types in the given scope.
* The search can be selecting specific types (given a package name using specific match mode
* and/or a type name using another specific match mode).
*
* @param packageName
* the full name of the package of the searched types, or a prefix for this
* package, or a wild-carded string for this package.
* May be <code>null</code>, then any package name is accepted.
* @param typeName
* the dot-separated qualified name of the searched type (the qualification include
* the enclosing types if the searched type is a member type), or a prefix
* for this type, or a wild-carded string for this type.
* May be <code>null</code>, then any type name is accepted.
* @param packageMatchRule
* one of
* <ul>
* <li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type
* name are the full names of the searched types.</li>
* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type
* name are prefixes of the names of the searched types.</li>
* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and
* type name contain wild-cards.</li>
* <li>{@link SearchPattern#R_CAMELCASE_MATCH} if the package name is a
* camel case of the searched types package name.</li>
* <li>{@link SearchPattern#R_CAMELCASE_SAME_PART_COUNT_MATCH}
* if the package name is a camel case with same part count of the searched
* types package name.</li>
* </ul>
* combined with {@link SearchPattern#R_CASE_SENSITIVE},
* e.g. {@link SearchPattern#R_EXACT_MATCH} | {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is
* requested,
* or {@link SearchPattern#R_PREFIX_MATCH} if a prefix non case sensitive match is requested.
* @param typeMatchRule
* one of
* <ul>
* <li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type
* name are the full names of the searched types.</li>
* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type
* name are prefixes of the names of the searched types.</li>
* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and
* type name contain wild-cards.</li>
* <li>{@link SearchPattern#R_CAMELCASE_MATCH} if the type name is a
* camel case of the searched types name.</li>
* <li>{@link SearchPattern#R_CAMELCASE_SAME_PART_COUNT_MATCH}
* if the type name is a camel case with same part count of the searched
* types name.</li>
* </ul>
* combined with {@link SearchPattern#R_CASE_SENSITIVE},
* e.g. {@link SearchPattern#R_EXACT_MATCH} | {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is
* requested,
* or {@link SearchPattern#R_PREFIX_MATCH} if a prefix non case sensitive match is requested.
* @param searchFor
* determines the nature of the searched elements
* <ul>
* <li>{@link IJavaSearchConstants#CLASS}: only look for classes</li>
* <li>{@link IJavaSearchConstants#INTERFACE}: only look for interfaces</li>
* <li>{@link IJavaSearchConstants#ENUM}: only look for enumeration</li>
* <li>{@link IJavaSearchConstants#ANNOTATION_TYPE}: only look for annotation type</li>
* <li>{@link IJavaSearchConstants#CLASS_AND_ENUM}: only look for classes and enumerations</li>
* <li>{@link IJavaSearchConstants#CLASS_AND_INTERFACE}: only look for classes and interfaces</li>
* <li>{@link IJavaSearchConstants#TYPE}: look for all types (i.e. classes, interfaces, enum and annotation types)</li>
* </ul>
* @param scope
* the scope to search in
* @param nameRequestor
* the requestor that collects the results of the search
* @param waitingPolicy
* one of
* <ul>
* <li>{@link IJavaSearchConstants#FORCE_IMMEDIATE_SEARCH} if the search should start immediately</li>
* <li>{@link IJavaSearchConstants#CANCEL_IF_NOT_READY_TO_SEARCH} if the search should be cancelled if the
* underlying indexer has not finished indexing the workspace</li>
* <li>{@link IJavaSearchConstants#WAIT_UNTIL_READY_TO_SEARCH} if the search should wait for the
* underlying indexer to finish indexing the workspace</li>
* </ul>
* @param progressMonitor
* the progress monitor to report progress to, or <code>null</code> if no progress
* monitor is provided
* @throws org.eclipse.jdt.core.JavaModelException
* if the search failed. Reasons include:
* <ul>
* <li>the classpath is incorrectly set</li>
* </ul>
* @since 3.3
*/
public void searchAllTypeNames(
final char[] packageName,
final int packageMatchRule,
final char[] typeName,
final int typeMatchRule,
int searchFor,
IJavaSearchScope scope,
final TypeNameRequestor nameRequestor,
int waitingPolicy,
IProgressMonitor progressMonitor) throws JavaModelException {
TypeNameRequestorWrapper requestorWrapper = new TypeNameRequestorWrapper(nameRequestor);
this.basicEngine.searchAllTypeNames(packageName,
packageMatchRule,
typeName,
typeMatchRule,
searchFor,
scope,
requestorWrapper,
waitingPolicy,
progressMonitor);
}
/**
* Searches for all top-level types and member types in the given scope.
* The search can be selecting specific types (given a package name using specific match mode
* and/or a type name using another specific match mode).
* <p>
* Provided {@link TypeNameMatchRequestor} requestor will collect {@link TypeNameMatch}
* matches found during the search.
* </p>
*
* @param packageName
* the full name of the package of the searched types, or a prefix for this
* package, or a wild-carded string for this package.
* May be <code>null</code>, then any package name is accepted.
* @param packageMatchRule
* one of
* <ul>
* <li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type
* name are the full names of the searched types.</li>
* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type
* name are prefixes of the names of the searched types.</li>
* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and
* type name contain wild-cards.</li>
* <li>{@link SearchPattern#R_CAMELCASE_MATCH} if the package name is a
* camel case of the searched types package name.</li>
* <li>{@link SearchPattern#R_CAMELCASE_SAME_PART_COUNT_MATCH}
* if the package name is a camel case with same part count of the searched
* types package name.</li>
* </ul>
* combined with {@link SearchPattern#R_CASE_SENSITIVE},
* e.g. {@link SearchPattern#R_EXACT_MATCH} | {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is
* requested,
* or {@link SearchPattern#R_PREFIX_MATCH} if a prefix non case sensitive match is requested.
* @param typeName
* the dot-separated qualified name of the searched type (the qualification include
* the enclosing types if the searched type is a member type), or a prefix
* for this type, or a wild-carded string for this type.
* May be <code>null</code>, then any type name is accepted.
* @param typeMatchRule
* one of
* <ul>
* <li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type
* name are the full names of the searched types.</li>
* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type
* name are prefixes of the names of the searched types.</li>
* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and
* type name contain wild-cards.</li>
* <li>{@link SearchPattern#R_CAMELCASE_MATCH} if the type name is a
* camel case of the searched types name.</li>
* <li>{@link SearchPattern#R_CAMELCASE_SAME_PART_COUNT_MATCH}
* if the type name is a camel case with same part count of the searched
* types name.</li>
* </ul>
* combined with {@link SearchPattern#R_CASE_SENSITIVE},
* e.g. {@link SearchPattern#R_EXACT_MATCH} | {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is
* requested,
* or {@link SearchPattern#R_PREFIX_MATCH} if a prefix non case sensitive match is requested.
* @param searchFor
* determines the nature of the searched elements
* <ul>
* <li>{@link IJavaSearchConstants#CLASS}: only look for classes</li>
* <li>{@link IJavaSearchConstants#INTERFACE}: only look for interfaces</li>
* <li>{@link IJavaSearchConstants#ENUM}: only look for enumeration</li>
* <li>{@link IJavaSearchConstants#ANNOTATION_TYPE}: only look for annotation type</li>
* <li>{@link IJavaSearchConstants#CLASS_AND_ENUM}: only look for classes and enumerations</li>
* <li>{@link IJavaSearchConstants#CLASS_AND_INTERFACE}: only look for classes and interfaces</li>
* <li>{@link IJavaSearchConstants#TYPE}: look for all types (i.e. classes, interfaces, enum and annotation types)</li>
* </ul>
* @param scope
* the scope to search in
* @param nameMatchRequestor
* the {@link TypeNameMatchRequestor requestor} that collects
* {@link TypeNameMatch matches} of the search.
* @param waitingPolicy
* one of
* <ul>
* <li>{@link IJavaSearchConstants#FORCE_IMMEDIATE_SEARCH} if the search should start immediately</li>
* <li>{@link IJavaSearchConstants#CANCEL_IF_NOT_READY_TO_SEARCH} if the search should be cancelled if the
* underlying indexer has not finished indexing the workspace</li>
* <li>{@link IJavaSearchConstants#WAIT_UNTIL_READY_TO_SEARCH} if the search should wait for the
* underlying indexer to finish indexing the workspace</li>
* </ul>
* @param progressMonitor
* the progress monitor to report progress to, or <code>null</code> if no progress
* monitor is provided
* @throws org.eclipse.jdt.core.JavaModelException
* if the search failed. Reasons include:
* <ul>
* <li>the classpath is incorrectly set</li>
* </ul>
* @since 3.3
*/
public void searchAllTypeNames(
final char[] packageName,
final int packageMatchRule,
final char[] typeName,
final int typeMatchRule,
int searchFor,
IJavaSearchScope scope,
final TypeNameMatchRequestor nameMatchRequestor,
int waitingPolicy,
IProgressMonitor progressMonitor) throws JavaModelException {
TypeNameMatchRequestorWrapper requestorWrapper = new TypeNameMatchRequestorWrapper(nameMatchRequestor, scope);
this.basicEngine.searchAllTypeNames(packageName,
packageMatchRule,
typeName,
typeMatchRule,
searchFor,
scope,
requestorWrapper,
waitingPolicy,
progressMonitor);
}
/**
* Searches for all top-level types and member types in the given scope matching any of the given qualifications
* and type names in a case sensitive way.
*
* @param qualifications
* the qualified name of the package/enclosing type of the searched types.
* May be <code>null</code>, then any package name is accepted.
* @param typeNames
* the simple names of the searched types.
* If this parameter is <code>null</code>, then no type will be found.
* @param scope
* the scope to search in
* @param nameRequestor
* the requestor that collects the results of the search
* @param waitingPolicy
* one of
* <ul>
* <li>{@link IJavaSearchConstants#FORCE_IMMEDIATE_SEARCH} if the search should start immediately</li>
* <li>{@link IJavaSearchConstants#CANCEL_IF_NOT_READY_TO_SEARCH} if the search should be cancelled if the
* underlying indexer has not finished indexing the workspace</li>
* <li>{@link IJavaSearchConstants#WAIT_UNTIL_READY_TO_SEARCH} if the search should wait for the
* underlying indexer to finish indexing the workspace</li>
* </ul>
* @param progressMonitor
* the progress monitor to report progress to, or <code>null</code> if no progress
* monitor is provided
* @throws org.eclipse.jdt.core.JavaModelException
* if the search failed. Reasons include:
* <ul>
* <li>the classpath is incorrectly set</li>
* </ul>
* @since 3.1
*/
public void searchAllTypeNames(
final char[][] qualifications,
final char[][] typeNames,
IJavaSearchScope scope,
final TypeNameRequestor nameRequestor,
int waitingPolicy,
IProgressMonitor progressMonitor) throws JavaModelException {
TypeNameRequestorWrapper requestorWrapper = new TypeNameRequestorWrapper(nameRequestor);
this.basicEngine.searchAllTypeNames(
qualifications,
typeNames,
SearchPattern.R_EXACT_MATCH | SearchPattern.R_CASE_SENSITIVE,
IJavaSearchConstants.TYPE,
scope,
requestorWrapper,
waitingPolicy,
progressMonitor);
}
/**
* Searches for all top-level types and member types in the given scope matching any of the given qualifications
* and type names in a case sensitive way.
* <p>
* Provided {@link TypeNameMatchRequestor} requestor will collect {@link TypeNameMatch}
* matches found during the search.
* </p>
*
* @param qualifications
* the qualified name of the package/enclosing type of the searched types.
* May be <code>null</code>, then any package name is accepted.
* @param typeNames
* the simple names of the searched types.
* If this parameter is <code>null</code>, then no type will be found.
* @param scope
* the scope to search in
* @param nameMatchRequestor
* the {@link TypeNameMatchRequestor requestor} that collects
* {@link TypeNameMatch matches} of the search.
* @param waitingPolicy
* one of
* <ul>
* <li>{@link IJavaSearchConstants#FORCE_IMMEDIATE_SEARCH} if the search should start immediately</li>
* <li>{@link IJavaSearchConstants#CANCEL_IF_NOT_READY_TO_SEARCH} if the search should be cancelled if the
* underlying indexer has not finished indexing the workspace</li>
* <li>{@link IJavaSearchConstants#WAIT_UNTIL_READY_TO_SEARCH} if the search should wait for the
* underlying indexer to finish indexing the workspace</li>
* </ul>
* @param progressMonitor
* the progress monitor to report progress to, or <code>null</code> if no progress
* monitor is provided
* @throws org.eclipse.jdt.core.JavaModelException
* if the search failed. Reasons include:
* <ul>
* <li>the classpath is incorrectly set</li>
* </ul>
* @since 3.3
*/
public void searchAllTypeNames(
final char[][] qualifications,
final char[][] typeNames,
IJavaSearchScope scope,
final TypeNameMatchRequestor nameMatchRequestor,
int waitingPolicy,
IProgressMonitor progressMonitor) throws JavaModelException {
TypeNameMatchRequestorWrapper requestorWrapper = new TypeNameMatchRequestorWrapper(nameMatchRequestor, scope);
this.basicEngine.searchAllTypeNames(
qualifications,
typeNames,
SearchPattern.R_EXACT_MATCH | SearchPattern.R_CASE_SENSITIVE,
IJavaSearchConstants.TYPE,
scope,
requestorWrapper,
waitingPolicy,
progressMonitor);
}
/**
* Searches for all top-level types and member types in the given scope.
* The search can be selecting specific types (given a package or a type name
* prefix and match modes).
*
* @param packageName
* the full name of the package of the searched types, or a prefix for this
* package, or a wild-carded string for this package.
* @param typeName
* the dot-separated qualified name of the searched type (the qualification include
* the enclosing types if the searched type is a member type), or a prefix
* for this type, or a wild-carded string for this type.
* @param matchRule
* one of
* <ul>
* <li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type name are the full names
* of the searched types.</li>
* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type name are prefixes of the names
* of the searched types.</li>
* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and type name contain wild-cards.</li>
* </ul>
* combined with {@link SearchPattern#R_CASE_SENSITIVE},
* e.g. {@link SearchPattern#R_EXACT_MATCH} | {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is
* requested,
* or {@link SearchPattern#R_PREFIX_MATCH} if a prefix non case sensitive match is requested.
* @param searchFor
* one of
* <ul>
* <li>{@link IJavaSearchConstants#CLASS} if searching for classes only</li>
* <li>{@link IJavaSearchConstants#INTERFACE} if searching for interfaces only</li>
* <li>{@link IJavaSearchConstants#TYPE} if searching for both classes and interfaces</li>
* </ul>
* @param scope
* the scope to search in
* @param nameRequestor
* the requestor that collects the results of the search
* @param waitingPolicy
* one of
* <ul>
* <li>{@link IJavaSearchConstants#FORCE_IMMEDIATE_SEARCH} if the search should start immediately</li>
* <li>{@link IJavaSearchConstants#CANCEL_IF_NOT_READY_TO_SEARCH} if the search should be cancelled if the
* underlying indexer has not finished indexing the workspace</li>
* <li>{@link IJavaSearchConstants#WAIT_UNTIL_READY_TO_SEARCH} if the search should wait for the
* underlying indexer to finish indexing the workspace</li>
* </ul>
* @param progressMonitor
* the progress monitor to report progress to, or <code>null</code> if no progress
* monitor is provided
* @throws org.eclipse.jdt.core.JavaModelException
* if the search failed. Reasons include:
* <ul>
* <li>the classpath is incorrectly set</li>
* </ul>
* @since 3.0
* @deprecated Use {@link #searchAllTypeNames(char[], char[], int, int, IJavaSearchScope, TypeNameRequestor, int,
* org.eclipse.core.runtime.IProgressMonitor)} instead
*/
public void searchAllTypeNames(
final char[] packageName,
final char[] typeName,
final int matchRule,
int searchFor,
IJavaSearchScope scope,
final ITypeNameRequestor nameRequestor,
int waitingPolicy,
IProgressMonitor progressMonitor) throws JavaModelException {
TypeNameRequestorAdapter requestorAdapter = new TypeNameRequestorAdapter(nameRequestor);
this.basicEngine
.searchAllTypeNames(packageName, SearchPattern.R_EXACT_MATCH, typeName, matchRule, searchFor, scope, requestorAdapter,
waitingPolicy, progressMonitor);
}
/**
* Searches for all top-level types and member types in the given scope.
* The search can be selecting specific types (given a package or a type name
* prefix and match modes).
*
* @param workspace
* the workspace to search in
* @param packageName
* the full name of the package of the searched types, or a prefix for this
* package, or a wild-carded string for this package.
* @param typeName
* the dot-separated qualified name of the searched type (the qualification include
* the enclosing types if the searched type is a member type), or a prefix
* for this type, or a wild-carded string for this type.
* @param matchMode
* one of
* <ul>
* <li>{@link IJavaSearchConstants#EXACT_MATCH} if the package name and type name are the full names
* of the searched types.</li>
* <li>{@link IJavaSearchConstants#PREFIX_MATCH} if the package name and type name are prefixes of the names
* of the searched types.</li>
* <li>{@link IJavaSearchConstants#PATTERN_MATCH} if the package name and type name contain wild-cards.</li>
* </ul>
* @param isCaseSensitive
* whether the search should be case sensitive
* @param searchFor
* one of
* <ul>
* <li>{@link IJavaSearchConstants#CLASS} if searching for classes only</li>
* <li>{@link IJavaSearchConstants#INTERFACE} if searching for interfaces only</li>
* <li>{@link IJavaSearchConstants#TYPE} if searching for both classes and interfaces</li>
* </ul>
* @param scope
* the scope to search in
* @param nameRequestor
* the requestor that collects the results of the search
* @param waitingPolicy
* one of
* <ul>
* <li>{@link IJavaSearchConstants#FORCE_IMMEDIATE_SEARCH} if the search should start immediately</li>
* <li>{@link IJavaSearchConstants#CANCEL_IF_NOT_READY_TO_SEARCH} if the search should be cancelled if the
* underlying indexer has not finished indexing the workspace</li>
* <li>{@link IJavaSearchConstants#WAIT_UNTIL_READY_TO_SEARCH} if the search should wait for the
* underlying indexer to finish indexing the workspace</li>
* </ul>
* @param progressMonitor
* the progress monitor to report progress to, or <code>null</code> if no progress
* monitor is provided
* @throws org.eclipse.jdt.core.JavaModelException
* if the search failed. Reasons include:
* <ul>
* <li>the classpath is incorrectly set</li>
* </ul>
* @deprecated Use {@link #searchAllTypeNames(char[], char[], int, int, IJavaSearchScope, ITypeNameRequestor, int,
* org.eclipse.core.runtime.IProgressMonitor)} instead
*/
public void searchAllTypeNames(
IWorkspace workspace,
final char[] packageName,
final char[] typeName,
final int matchMode,
final boolean isCaseSensitive,
int searchFor,
IJavaSearchScope scope,
final ITypeNameRequestor nameRequestor,
int waitingPolicy,
IProgressMonitor progressMonitor) throws JavaModelException {
searchAllTypeNames(
packageName,
typeName,
isCaseSensitive ? matchMode | SearchPattern.R_CASE_SENSITIVE : matchMode,
searchFor,
scope,
nameRequestor,
waitingPolicy,
progressMonitor);
}
/**
* Searches for all declarations of the fields accessed in the given element.
* The element can be a compilation unit or a source type/method/field.
* Reports the field declarations using the given requestor.
* <p>
* Consider the following code:
* <code>
* <pre>
* class A {
* int field1;
* }
* class B extends A {
* String value;
* }
* class X {
* void test() {
* B b = new B();
* System.out.println(b.value + b.field1);
* };
* }
* </pre>
* </code>
* then searching for declarations of accessed fields in method
* <code>X.test()</code> would collect the fields
* <code>B.value</code> and <code>A.field1</code>.
* </p>
*
* @param enclosingElement
* the field, method, type, or compilation unit to be searched in
* @param requestor
* a callback object to which each match is reported
* @param monitor
* the progress monitor used to report progress
* @throws org.eclipse.jdt.core.JavaModelException
* if the search failed. Reasons include:
* <ul>
* <li>the element doesn't exist</li>
* <li>the classpath is incorrectly set</li>
* </ul>
* @throws IllegalArgumentException
* if the given java element has not the right type
* @since 3.0
*/
public void searchDeclarationsOfAccessedFields(IJavaElement enclosingElement, SearchRequestor requestor, IProgressMonitor monitor)
throws
JavaModelException {
this.basicEngine.searchDeclarationsOfAccessedFields(enclosingElement, requestor, monitor);
}
/**
* Searches for all declarations of the fields accessed in the given element.
* The element can be a compilation unit, a source type, or a source method.
* Reports the field declarations using the given collector.
* <p>
* Consider the following code:
* <code>
* <pre>
* class A {
* int field1;
* }
* class B extends A {
* String value;
* }
* class X {
* void test() {
* B b = new B();
* System.out.println(b.value + b.field1);
* };
* }
* </pre>
* </code>
* then searching for declarations of accessed fields in method
* <code>X.test()</code> would collect the fields
* <code>B.value</code> and <code>A.field1</code>.
* </p>
*
* @param workspace
* the workspace
* @param enclosingElement
* the method, type, or compilation unit to be searched in
* @param resultCollector
* a callback object to which each match is reported
* @throws org.eclipse.jdt.core.JavaModelException
* if the search failed. Reasons include:
* <ul>
* <li>the element doesn't exist</li>
* <li>the classpath is incorrectly set</li>
* </ul>
* @deprecated Use {@link #searchDeclarationsOfAccessedFields(org.eclipse.jdt.core.IJavaElement, SearchRequestor,
* org.eclipse.core.runtime.IProgressMonitor)} instead.
*/
public void searchDeclarationsOfAccessedFields(IWorkspace workspace, IJavaElement enclosingElement,
IJavaSearchResultCollector resultCollector) throws
JavaModelException {
SearchPattern pattern = new DeclarationOfAccessedFieldsPattern(enclosingElement);
this.basicEngine.searchDeclarations(enclosingElement, new ResultCollectorAdapter(resultCollector), pattern, resultCollector
.getProgressMonitor());
}
/**
* Searches for all declarations of the types referenced in the given element.
* The element can be a compilation unit or a source type/method/field.
* Reports the type declarations using the given requestor.
* <p>
* Consider the following code:
* <code>
* <pre>
* class A {
* }
* class B extends A {
* }
* interface I {
* int VALUE = 0;
* }
* class X {
* void test() {
* B b = new B();
* this.foo(b, I.VALUE);
* };
* }
* </pre>
* </code>
* then searching for declarations of referenced types in method <code>X.test()</code>
* would collect the class <code>B</code> and the interface <code>I</code>.
* </p>
*
* @param enclosingElement
* the field, method, type, or compilation unit to be searched in
* @param requestor
* a callback object to which each match is reported
* @param monitor
* the progress monitor used to report progress
* @throws org.eclipse.jdt.core.JavaModelException
* if the search failed. Reasons include:
* <ul>
* <li>the element doesn't exist</li>
* <li>the classpath is incorrectly set</li>
* </ul>
* @throws IllegalArgumentException
* if the given java element has not the right type
* @since 3.0
*/
public void searchDeclarationsOfReferencedTypes(IJavaElement enclosingElement, SearchRequestor requestor, IProgressMonitor monitor)
throws
JavaModelException {
this.basicEngine.searchDeclarationsOfReferencedTypes(enclosingElement, requestor, monitor);
}
/**
* Searches for all declarations of the types referenced in the given element.
* The element can be a compilation unit, a source type, or a source method.
* Reports the type declarations using the given collector.
* <p>
* Consider the following code:
* <code>
* <pre>
* class A {
* }
* class B extends A {
* }
* interface I {
* int VALUE = 0;
* }
* class X {
* void test() {
* B b = new B();
* this.foo(b, I.VALUE);
* };
* }
* </pre>
* </code>
* then searching for declarations of referenced types in method <code>X.test()</code>
* would collect the class <code>B</code> and the interface <code>I</code>.
* </p>
*
* @param workspace
* the workspace
* @param enclosingElement
* the method, type, or compilation unit to be searched in
* @param resultCollector
* a callback object to which each match is reported
* @throws org.eclipse.jdt.core.JavaModelException
* if the search failed. Reasons include:
* <ul>
* <li>the element doesn't exist</li>
* <li>the classpath is incorrectly set</li>
* </ul>
* @deprecated Use {@link #searchDeclarationsOfReferencedTypes(org.eclipse.jdt.core.IJavaElement, SearchRequestor,
* org.eclipse.core.runtime.IProgressMonitor)} instead.
*/
public void searchDeclarationsOfReferencedTypes(IWorkspace workspace, IJavaElement enclosingElement,
IJavaSearchResultCollector resultCollector) throws
JavaModelException {
SearchPattern pattern = new DeclarationOfReferencedTypesPattern(enclosingElement);
this.basicEngine.searchDeclarations(enclosingElement, new ResultCollectorAdapter(resultCollector), pattern, resultCollector
.getProgressMonitor());
}
/**
* Searches for all declarations of the methods invoked in the given element.
* The element can be a compilation unit or a source type/method/field.
* Reports the method declarations using the given requestor.
* <p>
* Consider the following code:
* <code>
* <pre>
* class A {
* void foo() {};
* void bar() {};
* }
* class B extends A {
* void foo() {};
* }
* class X {
* void test() {
* A a = new B();
* a.foo();
* B b = (B)a;
* b.bar();
* };
* }
* </pre>
* </code>
* then searching for declarations of sent messages in method
* <code>X.test()</code> would collect the methods
* <code>A.foo()</code>, <code>B.foo()</code>, and <code>A.bar()</code>.
* </p>
*
* @param enclosingElement
* the field, method, type or compilation unit to be searched in
* @param requestor
* a callback object to which each match is reported
* @param monitor
* the progress monitor used to report progress
* @throws org.eclipse.jdt.core.JavaModelException
* if the search failed. Reasons include:
* <ul>
* <li>the element doesn't exist</li>
* <li>the classpath is incorrectly set</li>
* </ul>
* @throws IllegalArgumentException
* if the given java element has not the right type
* @since 3.0
*/
public void searchDeclarationsOfSentMessages(IJavaElement enclosingElement, SearchRequestor requestor, IProgressMonitor monitor) throws
JavaModelException {
this.basicEngine.searchDeclarationsOfSentMessages(enclosingElement, requestor, monitor);
}
/**
* Searches for all declarations of the methods invoked in the given element.
* The element can be a compilation unit, a source type, or a source method.
* Reports the method declarations using the given collector.
* <p>
* Consider the following code:
* <code>
* <pre>
* class A {
* void foo() {};
* void bar() {};
* }
* class B extends A {
* void foo() {};
* }
* class X {
* void test() {
* A a = new B();
* a.foo();
* B b = (B)a;
* b.bar();
* };
* }
* </pre>
* </code>
* then searching for declarations of sent messages in method
* <code>X.test()</code> would collect the methods
* <code>A.foo()</code>, <code>B.foo()</code>, and <code>A.bar()</code>.
* </p>
*
* @param workspace
* the workspace
* @param enclosingElement
* the method, type, or compilation unit to be searched in
* @param resultCollector
* a callback object to which each match is reported
* @throws org.eclipse.jdt.core.JavaModelException
* if the search failed. Reasons include:
* <ul>
* <li>the element doesn't exist</li>
* <li>the classpath is incorrectly set</li>
* </ul>
* @deprecated Use {@link #searchDeclarationsOfSentMessages(org.eclipse.jdt.core.IJavaElement, SearchRequestor,
* org.eclipse.core.runtime.IProgressMonitor)} instead.
*/
public void searchDeclarationsOfSentMessages(IWorkspace workspace, IJavaElement enclosingElement, IJavaSearchResultCollector
resultCollector) throws
JavaModelException {
SearchPattern pattern = new DeclarationOfReferencedMethodsPattern(enclosingElement);
this.basicEngine.searchDeclarations(enclosingElement, new ResultCollectorAdapter(resultCollector), pattern,
resultCollector.getProgressMonitor());
}
}