X-Git-Url: http://git.phpeclipse.com diff --git a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/core/SearchableEnvironment.java b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/core/SearchableEnvironment.java new file mode 100644 index 0000000..6bc4edc --- /dev/null +++ b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/core/SearchableEnvironment.java @@ -0,0 +1,302 @@ +/******************************************************************************* + * Copyright (c) 2000, 2003 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Common Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/cpl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package net.sourceforge.phpdt.internal.core; + +import net.sourceforge.phpdt.core.ICompilationUnit; +import net.sourceforge.phpdt.core.IJavaElement; +import net.sourceforge.phpdt.core.IJavaProject; +import net.sourceforge.phpdt.core.IPackageFragment; +import net.sourceforge.phpdt.core.IType; +import net.sourceforge.phpdt.core.JavaModelException; +import net.sourceforge.phpdt.core.compiler.CharOperation; +import net.sourceforge.phpdt.core.search.IJavaSearchConstants; +import net.sourceforge.phpdt.core.search.ITypeNameRequestor; +import net.sourceforge.phpdt.internal.codeassist.ISearchRequestor; +import net.sourceforge.phpdt.internal.codeassist.ISearchableNameEnvironment; +import net.sourceforge.phpdt.internal.compiler.env.IConstants; +import net.sourceforge.phpdt.internal.compiler.env.ISourceType; +import net.sourceforge.phpdt.internal.compiler.env.NameEnvironmentAnswer; + +import org.eclipse.core.runtime.IProgressMonitor; + +/** + * This class provides a SearchableBuilderEnvironment for code assist which + * uses the Java model as a search tool. + */ +public class SearchableEnvironment implements ISearchableNameEnvironment, IJavaSearchConstants { + protected NameLookup nameLookup; + protected ICompilationUnit unitToSkip; + + protected IJavaProject project; + // protected IJavaSearchScope searchScope; + + /** + * Creates a SearchableEnvironment on the given project + */ + public SearchableEnvironment(IJavaProject project) throws JavaModelException { + this.project = project; + this.nameLookup = (NameLookup) ((JavaProject) project).getNameLookup(); + + // Create search scope with visible entry on the project's classpath + // this.searchScope = SearchEngine.createJavaSearchScope(this.project.getAllPackageFragmentRoots()); + } + + /** + * Returns the given type in the the given package if it exists, + * otherwise null. + */ + protected NameEnvironmentAnswer find(String typeName, String packageName) { + if (packageName == null) + packageName = IPackageFragment.DEFAULT_PACKAGE_NAME; + + IType type = this.nameLookup.findType(typeName, packageName, false, NameLookup.ACCEPT_CLASSES | NameLookup.ACCEPT_INTERFACES); + if (type != null) { + // if (type instanceof BinaryType) { + // try { + // return new NameEnvironmentAnswer( + // (IBinaryType) ((BinaryType) type).getElementInfo()); + // } catch (JavaModelException npe) { + // return null; + // } + // } else { //SourceType + try { + // retrieve the requested type + SourceTypeElementInfo sourceType = (SourceTypeElementInfo) ((SourceType) type).getElementInfo(); + ISourceType topLevelType = sourceType; + while (topLevelType.getEnclosingType() != null) { + topLevelType = topLevelType.getEnclosingType(); + } + // find all siblings (other types declared in same unit, since may be used for name resolution) + IType[] types = sourceType.getHandle().getCompilationUnit().getTypes(); + ISourceType[] sourceTypes = new ISourceType[types.length]; + + // in the resulting collection, ensure the requested type is the first one + sourceTypes[0] = sourceType; + for (int i = 0, index = 1; i < types.length; i++) { + ISourceType otherType = (ISourceType) ((JavaElement) types[i]).getElementInfo(); + if (!otherType.equals(topLevelType)) + sourceTypes[index++] = otherType; + } + return new NameEnvironmentAnswer(sourceTypes); + } catch (JavaModelException npe) { + return null; + } + // } + } + return null; + } + + /** + * @see ISearchableNameEnvironment#findPackages(char[], ISearchRequestor) + */ + public void findPackages(char[] prefix, ISearchRequestor requestor) { + // this.nameLookup.seekPackageFragments( + // new String(prefix), + // true, + // new SearchableEnvironmentRequestor(requestor)); + } + + /** + * @see INameEnvironment#findType(char[][]) + */ + public NameEnvironmentAnswer findType(char[][] compoundTypeName) { + if (compoundTypeName == null) + return null; + + int length = compoundTypeName.length; + if (length <= 1) { + if (length == 0) + return null; + return find(new String(compoundTypeName[0]), null); + } + + int lengthM1 = length - 1; + char[][] packageName = new char[lengthM1][]; + System.arraycopy(compoundTypeName, 0, packageName, 0, lengthM1); + + return find(new String(compoundTypeName[lengthM1]), CharOperation.toString(packageName)); + } + + /** + * @see INameEnvironment#findType(char[], char[][]) + */ + public NameEnvironmentAnswer findType(char[] name, char[][] packageName) { + if (name == null) + return null; + + return find(new String(name), packageName == null || packageName.length == 0 ? null : CharOperation.toString(packageName)); + } + + /** + * @see ISearchableNameEnvironment#findTypes(char[], ISearchRequestor) + */ + public void findTypes(char[] prefix, final ISearchRequestor storage) { + + /* + if (true){ + findTypes(new String(prefix), storage, NameLookup.ACCEPT_CLASSES | NameLookup.ACCEPT_INTERFACES); + return; + } + */ + // try { + final String excludePath; + if (this.unitToSkip != null) { + if (!(this.unitToSkip instanceof IJavaElement)) { + // revert to model investigation + findTypes(new String(prefix), storage, NameLookup.ACCEPT_CLASSES | NameLookup.ACCEPT_INTERFACES); + return; + } + excludePath = ((IJavaElement) this.unitToSkip).getPath().toString(); + } else { + excludePath = null; + } + int lastDotIndex = CharOperation.lastIndexOf('.', prefix); + char[] qualification, simpleName; + if (lastDotIndex < 0) { + qualification = null; + simpleName = CharOperation.toLowerCase(prefix); + } else { + qualification = CharOperation.subarray(prefix, 0, lastDotIndex); + simpleName = CharOperation.toLowerCase(CharOperation.subarray(prefix, lastDotIndex + 1, prefix.length)); + } + + IProgressMonitor progressMonitor = new IProgressMonitor() { + boolean isCanceled = false; + public void beginTask(String name, int totalWork) { + } + public void done() { + } + public void internalWorked(double work) { + } + public boolean isCanceled() { + return isCanceled; + } + public void setCanceled(boolean value) { + isCanceled = value; + } + public void setTaskName(String name) { + } + public void subTask(String name) { + } + public void worked(int work) { + } + }; + ITypeNameRequestor nameRequestor = new ITypeNameRequestor() { + public void acceptClass(char[] packageName, char[] simpleTypeName, char[][] enclosingTypeNames, String path) { + if (excludePath != null && excludePath.equals(path)) + return; + if (enclosingTypeNames != null && enclosingTypeNames.length > 0) + return; // accept only top level types + storage.acceptClass(packageName, simpleTypeName, IConstants.AccPublic); + } + public void acceptInterface(char[] packageName, char[] simpleTypeName, char[][] enclosingTypeNames, String path) { + if (excludePath != null && excludePath.equals(path)) + return; + if (enclosingTypeNames != null && enclosingTypeNames.length > 0) + return; // accept only top level types + storage.acceptInterface(packageName, simpleTypeName, IConstants.AccPublic); + } + }; + // try { + // new SearchEngine().searchAllTypeNames( + // this.project.getProject().getWorkspace(), + // qualification, + // simpleName, + // PREFIX_MATCH, + // CASE_INSENSITIVE, + // IJavaSearchConstants.TYPE, + // this.searchScope, + // nameRequestor, + // CANCEL_IF_NOT_READY_TO_SEARCH, + // progressMonitor); + // } catch (OperationCanceledException e) { + // findTypes( + // new String(prefix), + // storage, + // NameLookup.ACCEPT_CLASSES | NameLookup.ACCEPT_INTERFACES); + // } + // } catch (JavaModelException e) { + // findTypes( + // new String(prefix), + // storage, + // NameLookup.ACCEPT_CLASSES | NameLookup.ACCEPT_INTERFACES); + // } + } + + /** + * Returns all types whose name starts with the given (qualified) prefix. + * + * If the prefix is unqualified, all types whose simple name matches + * the prefix are returned. + */ + private void findTypes(String prefix, ISearchRequestor storage, int type) { + SearchableEnvironmentRequestor requestor = new SearchableEnvironmentRequestor(storage, this.unitToSkip); + int index = prefix.lastIndexOf('.'); + if (index == -1) { + this.nameLookup.seekTypes(prefix, null, true, type, requestor); + } else { + String packageName = prefix.substring(0, index); + JavaElementRequestor elementRequestor = new JavaElementRequestor(); + this.nameLookup.seekPackageFragments(packageName, false, elementRequestor); + IPackageFragment[] fragments = elementRequestor.getPackageFragments(); + if (fragments != null) { + String className = prefix.substring(index + 1); + for (int i = 0, length = fragments.length; i < length; i++) + if (fragments[i] != null) + this.nameLookup.seekTypes(className, fragments[i], true, type, requestor); + } + } + } + + /** + * @see INameEnvironment#isPackage(char[][], char[]) + */ + public boolean isPackage(char[][] parentPackageName, char[] subPackageName) { + if (subPackageName == null || CharOperation.contains('.', subPackageName)) + return false; + if (parentPackageName == null || parentPackageName.length == 0) + return isTopLevelPackage(subPackageName); + for (int i = 0, length = parentPackageName.length; i < length; i++) + if (parentPackageName[i] == null || CharOperation.contains('.', parentPackageName[i])) + return false; + + String packageName = new String(CharOperation.concatWith(parentPackageName, subPackageName, '.')); + return this.nameLookup.findPackageFragments(packageName, false) != null; + } + + public boolean isTopLevelPackage(char[] packageName) { + return packageName != null + && !CharOperation.contains('.', packageName) + && this.nameLookup.findPackageFragments(new String(packageName), false) != null; + } + + /** + * Returns a printable string for the array. + */ + protected String toStringChar(char[] name) { + return "[" //$NON-NLS-1$ + + new String(name) + "]"; //$NON-NLS-1$ + } + + /** + * Returns a printable string for the array. + */ + protected String toStringCharChar(char[][] names) { + StringBuffer result = new StringBuffer(); + for (int i = 0; i < names.length; i++) { + result.append(toStringChar(names[i])); + } + return result.toString(); + } + + public void cleanup() { + } +}