Java SearchParticipant类代码示例

import org.eclipse.jdt.core.search.SearchParticipant; //导入依赖的package包/类
/**
 * search the bundle that contains the Main class. The search is done in the
 * workspace scope (ie. if it is defined in the current workspace it will
 * find it
 * 
 * @return the name of the bundle containing the Main class or null if not
 *         found
 */
private IType getITypeMainByWorkspaceScope(String className) {
	SearchPattern pattern = SearchPattern.createPattern(className, IJavaSearchConstants.CLASS,
			IJavaSearchConstants.DECLARATIONS, SearchPattern.R_EXACT_MATCH);
	IJavaSearchScope scope = SearchEngine.createWorkspaceScope();

	final List<IType> binaryType = new ArrayList<IType>();

	SearchRequestor requestor = new SearchRequestor() {
		@Override
		public void acceptSearchMatch(SearchMatch match) throws CoreException {
			binaryType.add((IType) match.getElement());
		}
	};
	SearchEngine engine = new SearchEngine();

	try {
		engine.search(pattern, new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() }, scope,
				requestor, null);
	} catch (CoreException e1) {
		throw new RuntimeException("Error while searching the bundle: " + e1.getMessage());
		// return new Status(IStatus.ERROR, Activator.PLUGIN_ID, );
	}

	return binaryType.isEmpty() ? null : binaryType.get(0);
}
 

import org.eclipse.jdt.core.search.SearchParticipant; //导入依赖的package包/类
/**
 * Searches for a class that matches a pattern.
 */
@VisibleForTesting
static boolean performSearch(SearchPattern pattern, IJavaSearchScope scope,
    IProgressMonitor monitor) {
  try {
    SearchEngine searchEngine = new SearchEngine();
    TypeSearchRequestor requestor = new TypeSearchRequestor();
    searchEngine.search(pattern,
        new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() },
        scope, requestor, monitor);
    return requestor.foundMatch();
  } catch (CoreException ex) {
    logger.log(Level.SEVERE, ex.getMessage());
    return false;
  }
}
 

import org.eclipse.jdt.core.search.SearchParticipant; //导入依赖的package包/类
private void findAllDeclarations(IProgressMonitor monitor, WorkingCopyOwner owner) throws CoreException {
	fDeclarations = new ArrayList<>();

	class MethodRequestor extends SearchRequestor {
		@Override
		public void acceptSearchMatch(SearchMatch match) throws CoreException {
			IMethod method = (IMethod) match.getElement();
			boolean isBinary = method.isBinary();
			if (!isBinary) {
				fDeclarations.add(method);
			}
		}
	}

	int limitTo = IJavaSearchConstants.DECLARATIONS | IJavaSearchConstants.IGNORE_DECLARING_TYPE | IJavaSearchConstants.IGNORE_RETURN_TYPE;
	int matchRule = SearchPattern.R_ERASURE_MATCH | SearchPattern.R_CASE_SENSITIVE;
	SearchPattern pattern = SearchPattern.createPattern(fMethod, limitTo, matchRule);
	MethodRequestor requestor = new MethodRequestor();
	SearchEngine searchEngine = owner != null ? new SearchEngine(owner) : new SearchEngine();

	searchEngine.search(pattern, new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() }, createSearchScope(), requestor, monitor);
}
 

import org.eclipse.jdt.core.search.SearchParticipant; //导入依赖的package包/类
private List<IType> searchType(String classFQN, IProgressMonitor monitor) {
	classFQN = classFQN.replace('$', '.');
	final List<IType> types = new ArrayList<IType>();

	IJavaSearchScope scope = SearchEngine.createWorkspaceScope();
	SearchEngine engine = new SearchEngine();
	SearchPattern pattern = SearchPattern.createPattern(classFQN, IJavaSearchConstants.TYPE,
			IJavaSearchConstants.DECLARATIONS, SearchPattern.R_EXACT_MATCH);

	SearchRequestor requestor = new SearchRequestor() {
		public void acceptSearchMatch(final SearchMatch match) throws CoreException {
			TypeDeclarationMatch typeMatch = (TypeDeclarationMatch) match;
			IType type = (IType) typeMatch.getElement();
			types.add(type);
		}
	};
	try {
		engine.search(pattern, new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() }, scope,
				requestor, monitor);
	} catch (final CoreException e) {
		return types;
	}

	return types;
}
 

import org.eclipse.jdt.core.search.SearchParticipant; //导入依赖的package包/类
private static List<Controller> search(IJavaProject project, SearchPattern namePattern) throws JavaModelException, CoreException {
    List<Controller> controllers = new ArrayList<Controller>();

    IJavaSearchScope scope = SearchEngine.createJavaSearchScope(project.getPackageFragments());

    SearchRequestor requestor = new SearchRequestor() {

        @Override
        public void acceptSearchMatch(SearchMatch match) {
            if (match.getElement() instanceof IJavaElement) {
                IJavaElement element = (IJavaElement) match.getElement();
                controllers.add(new Controller((IType) element));
            }
        }

    };

    SearchEngine searchEngine = new SearchEngine();
    searchEngine.search(namePattern, new SearchParticipant[] {SearchEngine
                    .getDefaultSearchParticipant()}, scope, requestor,
                    null);

    return controllers;
}
 

import org.eclipse.jdt.core.search.SearchParticipant; //导入依赖的package包/类
@Override
public void find() {
	
       SearchEngine engine = new SearchEngine();
       IJavaSearchScope workspaceScope = null;
       
       if(getProject() != null) {
       	workspaceScope = SearchEngine.createJavaSearchScope(createSearchScope());
       } else {
       	workspaceScope = SearchEngine.createWorkspaceScope();
       }
       
       SearchPattern pattern = SearchPattern.createPattern(
               		getElement().getPrimaryElement().getElementName().replace(Constants.JAVA_EXTENSION, Constants.EMPTY_STRING),
                       IJavaSearchConstants.TYPE,
                       IJavaSearchConstants.REFERENCES,
                       SearchPattern.R_EXACT_MATCH);
       SearchParticipant[] participant = new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() };
       try {
		engine.search(pattern, participant, workspaceScope, createSearchRequestor(), new NullProgressMonitor());
	} catch (CoreException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}
 

import org.eclipse.jdt.core.search.SearchParticipant; //导入依赖的package包/类
/**
 * Find all java files that match the class name
 * 
 * @param cls
 *            The class name
 * @return List of java files
 */
public static List<IJavaElement> search(String cls) {

	final List<IJavaElement> javaElements = new ArrayList<IJavaElement>();

	IJavaSearchScope scope = SearchEngine.createWorkspaceScope();
	SearchEngine engine = new SearchEngine();
	SearchPattern pattern = SearchPattern.createPattern(cls.split("\\.")[0], IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_EXACT_MATCH);

	SearchRequestor requestor = new SearchRequestor() {
		public void acceptSearchMatch(final SearchMatch match) throws CoreException {
			TypeDeclarationMatch typeMatch = (TypeDeclarationMatch) match;
			IJavaElement type = (IJavaElement) typeMatch.getElement();
			javaElements.add(type);
		}
	};
	try {
		engine.search(pattern, new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() }, scope, requestor, new NullProgressMonitor());
	}
	catch (final CoreException e) {
		e.printStackTrace();
	}

	return javaElements;
}
 

import org.eclipse.jdt.core.search.SearchParticipant; //导入依赖的package包/类
public void searchMainMethods(IProgressMonitor pm, IJavaSearchScope scope, Collection<IType> dst) throws CoreException
{
	pm.beginTask("Searching for main methods...", 100);
	try
	{
		SearchPattern pattern = SearchPattern.createPattern("main(String[]) void",
				IJavaSearchConstants.METHOD, IJavaSearchConstants.DECLARATIONS,
				SearchPattern.R_EXACT_MATCH | SearchPattern.R_CASE_SENSITIVE); //$NON-NLS-1$
		SearchParticipant[] participants = new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() };
		IProgressMonitor searchMonitor = new SubProgressMonitor(pm, 100);
		ResultAggregator collector = new ResultAggregator(dst);
		new SearchEngine().search(pattern, participants, scope,	collector, searchMonitor);
	}
	finally
	{
		pm.done();
	}
}
 

import org.eclipse.jdt.core.search.SearchParticipant; //导入依赖的package包/类
private IType[] findTypes(String patternText, IProgressMonitor progressMonitor) {
    IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaProject[] { javaProject },
            IJavaSearchScope.SOURCES | IJavaSearchScope.REFERENCED_PROJECTS | IJavaSearchScope.SYSTEM_LIBRARIES |
            IJavaSearchScope.APPLICATION_LIBRARIES);
    SearchPattern pattern = createSearchPattern(patternText);
    SearchParticipant[] participants = new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() };
    ClassCollector collector = new ClassCollector();
    try {
        new SearchEngine().search(pattern, participants, scope, collector, progressMonitor);
    } catch (CoreException e) {
        logError(e);
        return new IType[0];
    }
    IType[] foundTypes = collector.getTypes().toArray(new IType[collector.getTypes().size()]);
    return foundTypes;
}
 

import org.eclipse.jdt.core.search.SearchParticipant; //导入依赖的package包/类
protected void search(String patternString, int searchFor, int limitTo, int matchRule, IJavaSearchScope scope, SearchRequestor requestor) throws CoreException {
	if (patternString.indexOf('*') != -1 || patternString.indexOf('?') != -1)
		matchRule |= SearchPattern.R_PATTERN_MATCH;
	SearchPattern pattern = SearchPattern.createPattern(
		patternString,
		searchFor,
		limitTo,
		matchRule);
	assertNotNull("Pattern should not be null", pattern);
	new SearchEngine().search(
		pattern,
		new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()},
		scope,
		requestor,
		null);
}
 

import org.eclipse.jdt.core.search.SearchParticipant; //导入依赖的package包/类
/**
 * Get java project from type.
 *
 * @param fullyQualifiedTypeName
 *            fully qualified name of type
 * @return java project
 * @throws CoreException
 *             CoreException
 */
private static List<IJavaProject> getJavaProjectFromType(String fullyQualifiedTypeName) throws CoreException {
    String[] splitItems = fullyQualifiedTypeName.split("/");
    // If the main class name contains the module name, should trim the module info.
    if (splitItems.length == 2) {
        fullyQualifiedTypeName = splitItems[1];
    }
    final String moduleName = splitItems.length == 2 ? splitItems[0] : null;

    SearchPattern pattern = SearchPattern.createPattern(
            fullyQualifiedTypeName,
            IJavaSearchConstants.TYPE,
            IJavaSearchConstants.DECLARATIONS,
            SearchPattern.R_EXACT_MATCH);
    IJavaSearchScope scope = SearchEngine.createWorkspaceScope();
    ArrayList<IJavaProject> projects = new ArrayList<>();
    SearchRequestor requestor = new SearchRequestor() {
        @Override
        public void acceptSearchMatch(SearchMatch match) {
            Object element = match.getElement();
            if (element instanceof IJavaElement) {
                IJavaProject project = ((IJavaElement) element).getJavaProject();
                if (moduleName == null || moduleName.equals(JdtUtils.getModuleName(project))) {
                    projects.add(project);
                }
            }
        }
    };
    SearchEngine searchEngine = new SearchEngine();
    searchEngine.search(pattern, new SearchParticipant[] {
        SearchEngine.getDefaultSearchParticipant() }, scope,
        requestor, null /* progress monitor */);

    return projects.stream().distinct().collect(Collectors.toList());
}
 

import org.eclipse.jdt.core.search.SearchParticipant; //导入依赖的package包/类
public void renameOccurrences(WorkspaceEdit edit, String newName, IProgressMonitor monitor) throws CoreException {
	if (fElement == null || !canRename()) {
		return;
	}

	IJavaElement[] elementsToSearch = null;

	if (fElement instanceof IMethod) {
		elementsToSearch = RippleMethodFinder.getRelatedMethods((IMethod) fElement, monitor, null);
	} else {
		elementsToSearch = new IJavaElement[] { fElement };
	}

	SearchPattern pattern = createOccurrenceSearchPattern(elementsToSearch);
	if (pattern == null) {
		return;
	}
	SearchEngine engine = new SearchEngine();
	engine.search(pattern, new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() }, createSearchScope(), new SearchRequestor() {

		@Override
		public void acceptSearchMatch(SearchMatch match) throws CoreException {
			Object o = match.getElement();
			if (o instanceof IJavaElement) {
				IJavaElement element = (IJavaElement) o;
				ICompilationUnit compilationUnit = (ICompilationUnit) element.getAncestor(IJavaElement.COMPILATION_UNIT);
				if (compilationUnit == null) {
					return;
				}
				TextEdit replaceEdit = collectMatch(match, element, compilationUnit, newName);
				if (replaceEdit != null) {
					convert(edit, compilationUnit, replaceEdit);
				}
			}
		}
	}, monitor);

}
 

import org.eclipse.jdt.core.search.SearchParticipant; //导入依赖的package包/类
private Set<SearchMatch> findReferences(Set<? extends IJavaElement> elements) throws CoreException {
	Set<SearchMatch> ret = new HashSet<>();
	for (IJavaElement elem : elements)
		new SearchEngine().search(
				SearchPattern.createPattern(elem, IJavaSearchConstants.REFERENCES, SearchPattern.R_EXACT_MATCH),
				new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() },
				SearchEngine.createWorkspaceScope(), new SearchRequestor() {

					@Override
					public void acceptSearchMatch(SearchMatch match) throws CoreException {
						ret.add(match);
					}
				}, new NullProgressMonitor());
	return ret;
}
 

import org.eclipse.jdt.core.search.SearchParticipant; //导入依赖的package包/类
void commenceSearch(SearchEngine engine, SearchPattern pattern,
		IJavaSearchScope scope, final SearchMatchPurpose purpose,
		IProgressMonitor monitor) throws CoreException {
	engine.search(pattern, new SearchParticipant[] { SearchEngine
			.getDefaultSearchParticipant() }, scope, new SearchRequestor() {

		public void acceptSearchMatch(SearchMatch match)
				throws CoreException {
			if (match.getAccuracy() == SearchMatch.A_ACCURATE
					&& !match.isInsideDocComment())
				matchToPurposeMap.put(match, purpose);
		}
	}, new SubProgressMonitor(monitor, 1,
			SubProgressMonitor.SUPPRESS_SUBTASK_LABEL));
}
 

import org.eclipse.jdt.core.search.SearchParticipant; //导入依赖的package包/类
private void findParameters(final int paramNumber, SearchPattern pattern)
		throws CoreException {

	final SearchRequestor requestor = new SearchRequestor() {

		public void acceptSearchMatch(SearchMatch match)
				throws CoreException {
			if (match.getAccuracy() == SearchMatch.A_ACCURATE
					&& !match.isInsideDocComment()) {
				IJavaElement elem = (IJavaElement) match.getElement();
				ASTNode node = Util.getASTNode(elem,
						ASTNodeProcessor.this.monitor);
				ParameterProcessingVisitor visitor = new ParameterProcessingVisitor(
						paramNumber, match.getOffset());
				node.accept(visitor);
				ASTNodeProcessor.this.found.addAll(visitor.getElements());

				for (Iterator it = visitor.getExpressions().iterator(); it
						.hasNext();) {
					Expression exp = (Expression) it.next();
					ASTNodeProcessor.this.processExpression(exp);
				}
			}
		}
	};

	final SearchEngine searchEngine = new SearchEngine();
	searchEngine.search(pattern, new SearchParticipant[] { SearchEngine
			.getDefaultSearchParticipant() }, this.scope, requestor, null);
}