NameLookup provides name resolution within a Java project.
* The name lookup facility uses the project's classpath to prioritize the order
* in which package fragments are searched when resolving a name.
*
*
* Name lookup only returns a handle when the named element actually exists in
* the model; otherwise null is returned.
*
*
* There are two logical sets of methods within this interface. Methods which
* start with find* are intended to be convenience methods for
* quickly finding an element within another element; for instance, for finding
* a class within a package. The other set of methods all begin with
* seek*. These methods do comprehensive searches of the
* IJavaProject returning hits in real time through an
* IJavaElementRequestor.
*
*/
public class NameLookup {
/**
* Accept flag for specifying classes.
*/
public static final int ACCEPT_CLASSES = 0x00000002;
/**
* Accept flag for specifying interfaces.
*/
public static final int ACCEPT_INTERFACES = 0x00000004;
/**
* The IPackageFragmentRoot's associated with the classpath
* of this NameLookup facility's project.
*/
protected IPackageFragmentRoot[] fPackageFragmentRoots = null;
/**
* Table that maps package names to lists of package fragments for all
* package fragments in the package fragment roots known by this name lookup
* facility. To allow > 1 package fragment with the same name, values are
* arrays of package fragments ordered as they appear on the classpath.
*/
protected Map fPackageFragments;
/**
* The IWorkspace that this NameLookup is configure within.
*/
protected IWorkspace workspace;
/**
* A map from compilation unit handles to units to look inside (compilation
* units or working copies). Allows working copies to take precedence over
* compilation units. The cache is a 2-level cache, first keyed by thread.
*/
protected PerThreadObject unitsToLookInside = new PerThreadObject();
public NameLookup(IJavaProject project) throws JavaModelException {
configureFromProject(project);
}
/**
* Returns true if:
*
ACCEPT_CLASSES bit is on
* ACCEPT_INTERFACES bit is on
* ACCEPT_CLASSES or
* ACCEPT_INTERFACES bit is on
* NameLookup based on the info of the given
* IJavaProject.
*
* @throws JavaModelException
* if the IJavaProject has no classpath.
*/
private void configureFromProject(IJavaProject project)
throws JavaModelException {
workspace = ResourcesPlugin.getWorkspace();
fPackageFragmentRoots = ((JavaProject) project)
.getAllPackageFragmentRoots();
fPackageFragments = new HashMap();
IPackageFragment[] frags = this.getPackageFragmentsInRoots(
fPackageFragmentRoots, project);
for (int i = 0; i < frags.length; i++) {
IPackageFragment fragment = frags[i];
IPackageFragment[] entry = (IPackageFragment[]) fPackageFragments
.get(fragment.getElementName());
if (entry == null) {
entry = new IPackageFragment[1];
entry[0] = fragment;
fPackageFragments.put(fragment.getElementName(), entry);
} else {
IPackageFragment[] copy = new IPackageFragment[entry.length + 1];
System.arraycopy(entry, 0, copy, 0, entry.length);
copy[entry.length] = fragment;
fPackageFragments.put(fragment.getElementName(), copy);
}
}
}
/**
* Finds every type in the project whose simple name matches the prefix,
* informing the requestor of each hit. The requestor is polled for
* cancellation at regular intervals.
*
*
* The partialMatch argument indicates partial matches should
* be considered.
*/
private void findAllTypes(String prefix, boolean partialMatch,
int acceptFlags, IJavaElementRequestor requestor) {
int count = fPackageFragmentRoots.length;
for (int i = 0; i < count; i++) {
if (requestor.isCanceled())
return;
IPackageFragmentRoot root = fPackageFragmentRoots[i];
IJavaElement[] packages = null;
try {
packages = root.getChildren();
} catch (JavaModelException npe) {
continue; // the root is not present, continue;
}
if (packages != null) {
for (int j = 0, packageCount = packages.length; j < packageCount; j++) {
if (requestor.isCanceled())
return;
seekTypes(prefix, (IPackageFragment) packages[j],
partialMatch, acceptFlags, requestor);
}
}
}
}
/**
* Returns the ICompilationUnit which defines the type named
* qualifiedTypeName, or null if none exists.
* The domain of the search is bounded by the classpath of the
* IJavaProject this NameLookup was obtained
* from.
*
* The name must be fully qualified (eg "java.lang.Object",
* "java.util.Hashtable$Entry")
*/
// public ICompilationUnit findCompilationUnit(String qualifiedTypeName) {
// String pkgName = IPackageFragment.DEFAULT_PACKAGE_NAME;
// String cuName = qualifiedTypeName;
//
// int index = qualifiedTypeName.lastIndexOf('.');
// if (index != -1) {
// pkgName = qualifiedTypeName.substring(0, index);
// cuName = qualifiedTypeName.substring(index + 1);
// }
// index = cuName.indexOf('$');
// if (index != -1) {
// cuName = cuName.substring(0, index);
// }
// cuName += ".java"; //$NON-NLS-1$
// IPackageFragment[] frags = (IPackageFragment[]) fPackageFragments
// .get(pkgName);
// if (frags != null) {
// for (int i = 0; i < frags.length; i++) {
// //IPackageFragment frag = frags[i];
// // if (!(frag instanceof JarPackageFragment)) {
// // ICompilationUnit cu= frag.getCompilationUnit(cuName);
// // if (cu != null && cu.exists()) {
// // return cu;
// // }
// // }
// }
// }
// return null;
// }
/**
* Returns the package fragment whose path matches the given (absolute)
* path, or null if none exist. The domain of the search is
* bounded by the classpath of the IJavaProject this
* NameLookup was obtained from. The path can be: - internal
* to the workbench: "/Project/src" - external to the workbench:
* "c:/jdk/classes.zip/java/lang"
*/
// public IPackageFragment findPackageFragment(IPath path) {
// if (!path.isAbsolute()) {
// throw new IllegalArgumentException(Util.bind("path.mustBeAbsolute")); //$NON-NLS-1$
// }
// /*
// * this code should rather use the package fragment map to find the
// * candidate package, then check if the respective enclosing root maps
// * to the one on this given IPath.
// */
// IResource possibleFragment = workspace.getRoot().findMember(path);
// if (possibleFragment == null) {
// // external jar
// for (int i = 0; i < fPackageFragmentRoots.length; i++) {
// IPackageFragmentRoot root = fPackageFragmentRoots[i];
// if (!root.isExternal()) {
// continue;
// }
// IPath rootPath = root.getPath();
// int matchingCount = rootPath.matchingFirstSegments(path);
// if (matchingCount != 0) {
// String name = path.toOSString();
// // + 1 is for the File.separatorChar
// name = name.substring(rootPath.toOSString().length() + 1,
// name.length());
// name = name.replace(File.separatorChar, '.');
// IJavaElement[] list = null;
// try {
// list = root.getChildren();
// } catch (JavaModelException npe) {
// continue; // the package fragment root is not present;
// }
// int elementCount = list.length;
// for (int j = 0; j < elementCount; j++) {
// IPackageFragment packageFragment = (IPackageFragment) list[j];
// if (nameMatches(name, packageFragment, false)) {
// return packageFragment;
// }
// }
// }
// }
// } else {
// IJavaElement fromFactory = JavaCore.create(possibleFragment);
// if (fromFactory == null) {
// return null;
// }
// if (fromFactory instanceof IPackageFragment) {
// return (IPackageFragment) fromFactory;
// } else if (fromFactory instanceof IJavaProject) {
// // default package in a default root
// JavaProject project = (JavaProject) fromFactory;
// try {
// IClasspathEntry entry = project.getClasspathEntryFor(path);
// if (entry != null) {
// IPackageFragmentRoot root = project
// .getPackageFragmentRoot(project.getResource());
// IPackageFragment[] pkgs = (IPackageFragment[]) fPackageFragments
// .get(IPackageFragment.DEFAULT_PACKAGE_NAME);
// if (pkgs == null) {
// return null;
// }
// for (int i = 0; i < pkgs.length; i++) {
// if (pkgs[i].getParent().equals(root)) {
// return pkgs[i];
// }
// }
// }
// } catch (JavaModelException e) {
// return null;
// }
// }
// }
// return null;
// }
/**
* Returns the package fragments whose name matches the given (qualified)
* name, or null if none exist.
*
* The name can be: - empty: "" - qualified: "pack.pack1.pack2"
*
* @param partialMatch
* partial name matches qualify when true, only
* exact name matches qualify when false
*/
public IPackageFragment[] findPackageFragments(String name,
boolean partialMatch) {
int count = fPackageFragmentRoots.length;
if (partialMatch) {
name = name.toLowerCase();
for (int i = 0; i < count; i++) {
IPackageFragmentRoot root = fPackageFragmentRoots[i];
IJavaElement[] list = null;
try {
list = root.getChildren();
} catch (JavaModelException npe) {
continue; // the package fragment root is not present;
}
int elementCount = list.length;
IPackageFragment[] result = new IPackageFragment[elementCount];
int resultLength = 0;
for (int j = 0; j < elementCount; j++) {
IPackageFragment packageFragment = (IPackageFragment) list[j];
if (nameMatches(name, packageFragment, true)) {
result[resultLength++] = packageFragment;
}
}
if (resultLength > 0) {
System.arraycopy(result, 0,
result = new IPackageFragment[resultLength], 0,
resultLength);
return result;
} else {
return null;
}
}
} else {
IPackageFragment[] fragments = (IPackageFragment[]) fPackageFragments
.get(name);
if (fragments != null) {
IPackageFragment[] result = new IPackageFragment[fragments.length];
int resultLength = 0;
for (int i = 0; i < fragments.length; i++) {
IPackageFragment packageFragment = fragments[i];
result[resultLength++] = packageFragment;
}
if (resultLength > 0) {
System.arraycopy(result, 0,
result = new IPackageFragment[resultLength], 0,
resultLength);
return result;
} else {
return null;
}
}
}
return null;
}
/**
*
*/
public IType findType(String typeName, String packageName,
boolean partialMatch, int acceptFlags) {
if (packageName == null) {
packageName = IPackageFragment.DEFAULT_PACKAGE_NAME;
}
JavaElementRequestor elementRequestor = new JavaElementRequestor();
seekPackageFragments(packageName, false, elementRequestor);
IPackageFragment[] packages = elementRequestor.getPackageFragments();
for (int i = 0, length = packages.length; i < length; i++) {
IType type = findType(typeName, packages[i], partialMatch,
acceptFlags);
if (type != null)
return type;
}
return null;
}
/**
* Returns all the package fragments found in the specified package fragment
* roots. Make sure the returned fragments have the given project as great
* parent. This ensures the name lookup will not refer to another project
* (through jar package fragment roots)
*/
private IPackageFragment[] getPackageFragmentsInRoots(
IPackageFragmentRoot[] roots, IJavaProject project) {
// The following code assumes that all the roots have the given project
// as their parent
ArrayList frags = new ArrayList();
for (int i = 0; i < roots.length; i++) {
IPackageFragmentRoot root = roots[i];
try {
IJavaElement[] children = root.getChildren();
/*
* 2 jar package fragment roots can be equals but not belonging
* to the same project. As a result, they share the same element
* info. So this jar package fragment root could get the
* children of another jar package fragment root. The following
* code ensures that the children of this jar package fragment
* root have the given project as a great parent.
*/
int length = children.length;
if (length == 0)
continue;
if (children[0].getParent().getParent().equals(project)) {
// the children have the right parent, simply add them to
// the list
for (int j = 0; j < length; j++) {
frags.add(children[j]);
}
} else {
// create a new handle with the root as the parent
for (int j = 0; j < length; j++) {
frags.add(root.getPackageFragment(children[j]
.getElementName()));
}
}
} catch (JavaModelException e) {
// do nothing
}
}
IPackageFragment[] fragments = new IPackageFragment[frags.size()];
frags.toArray(fragments);
return fragments;
}
/**
* Returns the first type in the given package whose name matches the given
* (unqualified) name, or null if none exist. Specifying a
* null package will result in no matches. The domain of the
* search is bounded by the Java project from which this name lookup was
* obtained.
*
* @param name
* the name of the type to find
* @param pkg
* the package to search
* @param partialMatch
* partial name matches qualify when true, only
* exact name matches qualify when false
* @param acceptFlags
* a bit mask describing if classes, interfaces or both classes
* and interfaces are desired results. If no flags are specified,
* all types are returned.
*
* @see #ACCEPT_CLASSES
* @see #ACCEPT_INTERFACES
*/
public IType findType(String name, IPackageFragment pkg,
boolean partialMatch, int acceptFlags) {
if (pkg == null) {
return null;
}
// Return first found (ignore duplicates).
// synchronized(JavaModelManager.getJavaModelManager()){
// SingleTypeRequestor typeRequestor = new SingleTypeRequestor();
// seekTypes(name, pkg, partialMatch, acceptFlags, typeRequestor);
// IType type= typeRequestor.getType();
// return type;
// }
return null;
}
/**
* Returns the type specified by the qualified name, or null
* if none exist. The domain of the search is bounded by the Java project
* from which this name lookup was obtained.
*
* @param name
* the name of the type to find
* @param partialMatch
* partial name matches qualify when true, only
* exact name matches qualify when false
* @param acceptFlags
* a bit mask describing if classes, interfaces or both classes
* and interfaces are desired results. If no flags are specified,
* all types are returned.
*
* @see #ACCEPT_CLASSES
* @see #ACCEPT_INTERFACES
*/
public IType findType(String name, boolean partialMatch, int acceptFlags) {
int index = name.lastIndexOf('.');
String className = null, packageName = null;
if (index == -1) {
packageName = IPackageFragment.DEFAULT_PACKAGE_NAME;
className = name;
} else {
packageName = name.substring(0, index);
className = name.substring(index + 1);
}
return findType(className, packageName, partialMatch, acceptFlags);
}
/**
* Returns true if the given element's name matches the specified
* searchName, otherwise false.
*
*
* The partialMatch argument indicates partial matches should
* be considered. NOTE: in partialMatch mode, the case will be ignored, and
* the searchName must already have been lowercased.
*/
protected boolean nameMatches(String searchName, IJavaElement element,
boolean partialMatch) {
if (partialMatch) {
// partial matches are used in completion mode, thus case
// insensitive mode
return element.getElementName().toLowerCase()
.startsWith(searchName);
} else {
return element.getElementName().equals(searchName);
}
}
/**
* Notifies the given requestor of all package fragments with the given
* name. Checks the requestor at regular intervals to see if the requestor
* has canceled. The domain of the search is bounded by the
* IJavaProject this NameLookup was obtained
* from.
*
* @param partialMatch
* partial name matches qualify when true; only
* exact name matches qualify when false
*/
public void seekPackageFragments(String name, boolean partialMatch,
IJavaElementRequestor requestor) {
int count = fPackageFragmentRoots.length;
String matchName = partialMatch ? name.toLowerCase() : name;
for (int i = 0; i < count; i++) {
if (requestor.isCanceled())
return;
IPackageFragmentRoot root = fPackageFragmentRoots[i];
IJavaElement[] list = null;
try {
list = root.getChildren();
} catch (JavaModelException npe) {
continue; // this root package fragment is not present
}
int elementCount = list.length;
for (int j = 0; j < elementCount; j++) {
if (requestor.isCanceled())
return;
IPackageFragment packageFragment = (IPackageFragment) list[j];
if (nameMatches(matchName, packageFragment, partialMatch))
requestor.acceptPackageFragment(packageFragment);
}
}
}
/**
* Notifies the given requestor of all types (classes and interfaces) in the
* given package fragment with the given (unqualified) name. Checks the
* requestor at regular intervals to see if the requestor has canceled. If
* the given package fragment is null, all types in the
* project whose simple name matches the given name are found.
*
* @param name
* The name to search
* @param pkg
* The corresponding package fragment
* @param partialMatch
* partial name matches qualify when true; only
* exact name matches qualify when false
* @param acceptFlags
* a bit mask describing if classes, interfaces or both classes
* and interfaces are desired results. If no flags are specified,
* all types are returned.
* @param requestor
* The requestor that collects the result
*
* @see #ACCEPT_CLASSES
* @see #ACCEPT_INTERFACES
*/
public void seekTypes(String name, IPackageFragment pkg,
boolean partialMatch, int acceptFlags,
IJavaElementRequestor requestor) {
String matchName = partialMatch ? name.toLowerCase() : name;
if (matchName.indexOf('.') >= 0) { // looks for member type A.B
matchName = matchName.replace('.', '$');
}
if (pkg == null) {
findAllTypes(matchName, partialMatch, acceptFlags, requestor);
return;
}
IPackageFragmentRoot root = (IPackageFragmentRoot) pkg.getParent();
try {
int packageFlavor = root.getKind();
switch (packageFlavor) {
// case IPackageFragmentRoot.K_BINARY :
// seekTypesInBinaryPackage(matchName, pkg, partialMatch,
// acceptFlags, requestor);
// break;
case IPackageFragmentRoot.K_SOURCE:
seekTypesInSourcePackage(matchName, pkg, partialMatch,
acceptFlags, requestor);
break;
default:
return;
}
} catch (JavaModelException e) {
return;
}
}
/**
* Performs type search in a binary package.
*/
// protected void seekTypesInBinaryPackage(String name, IPackageFragment
// pkg, boolean partialMatch, int acceptFlags, IJavaElementRequestor
// requestor) {
// IClassFile[] classFiles= null;
// try {
// classFiles= pkg.getClassFiles();
// } catch (JavaModelException npe) {
// return; // the package is not present
// }
// int length= classFiles.length;
//
// String unqualifiedName= name;
// int index= name.lastIndexOf('$');
// if (index != -1) {
// //the type name of the inner type
// unqualifiedName= name.substring(index + 1, name.length());
// // unqualifiedName is empty if the name ends with a '$' sign.
// // See http://dev.eclipse.org/bugs/show_bug.cgi?id=14642
// if ((unqualifiedName.length() > 0 &&
// Character.isDigit(unqualifiedName.charAt(0))) || unqualifiedName.length()
// == 0){
// unqualifiedName = name;
// }
// }
// String matchName= partialMatch ? name.toLowerCase() : name;
// for (int i= 0; i < length; i++) {
// if (requestor.isCanceled())
// return;
// IClassFile classFile= classFiles[i];
// String elementName = classFile.getElementName();
// if (partialMatch) elementName = elementName.toLowerCase();
//
// /**
// * Must use startWith because matchName will never have the
// * extension ".class" and the elementName always will.
// */
// if (elementName.startsWith(matchName)) {
// IType type= null;
// try {
// type= classFile.getType();
// } catch (JavaModelException npe) {
// continue; // the classFile is not present
// }
// if (!partialMatch || (type.getElementName().length() > 0 &&
// !Character.isDigit(type.getElementName().charAt(0)))) { //not an
// anonymous type
// if (nameMatches(unqualifiedName, type, partialMatch) && acceptType(type,
// acceptFlags))
// requestor.acceptType(type);
// }
// }
// }
// }
/**
* Performs type search in a source package.
*/
protected void seekTypesInSourcePackage(String name, IPackageFragment pkg,
boolean partialMatch, int acceptFlags,
IJavaElementRequestor requestor) {
ICompilationUnit[] compilationUnits = null;
try {
compilationUnits = pkg.getCompilationUnits();
} catch (JavaModelException npe) {
return; // the package is not present
}
int length = compilationUnits.length;
String matchName = name;
int index = name.indexOf('$');
boolean potentialMemberType = false;
String potentialMatchName = null;
if (index != -1) {
// the compilation unit name of the inner type
potentialMatchName = name.substring(0, index);
potentialMemberType = true;
}
/**
* In the following, matchName will never have the extension ".java" and
* the compilationUnits always will. So add it if we're looking for an
* exact match.
*/
String unitName = partialMatch ? matchName.toLowerCase() : matchName
+ ".java"; //$NON-NLS-1$
String potentialUnitName = null;
if (potentialMemberType) {
potentialUnitName = partialMatch ? potentialMatchName.toLowerCase()
: potentialMatchName + ".java"; //$NON-NLS-1$
}
for (int i = 0; i < length; i++) {
if (requestor.isCanceled())
return;
ICompilationUnit compilationUnit = compilationUnits[i];
// unit to look inside
ICompilationUnit unitToLookInside = null;
Map workingCopies = (Map) this.unitsToLookInside.getCurrent();
if (workingCopies != null
&& (unitToLookInside = (ICompilationUnit) workingCopies
.get(compilationUnit)) != null) {
compilationUnit = unitToLookInside;
}
if ((unitToLookInside != null && !potentialMemberType)
|| nameMatches(unitName, compilationUnit, partialMatch)) {
IType[] types = null;
try {
types = compilationUnit.getTypes();
} catch (JavaModelException npe) {
continue; // the compilation unit is not present
}
int typeLength = types.length;
for (int j = 0; j < typeLength; j++) {
if (requestor.isCanceled())
return;
IType type = types[j];
if (nameMatches(matchName, type, partialMatch)) {
if (acceptType(type, acceptFlags))
requestor.acceptType(type);
}
}
} else if (potentialMemberType
&& nameMatches(potentialUnitName, compilationUnit,
partialMatch)) {
IType[] types = null;
try {
types = compilationUnit.getTypes();
} catch (JavaModelException npe) {
continue; // the compilation unit is not present
}
int typeLength = types.length;
for (int j = 0; j < typeLength; j++) {
if (requestor.isCanceled())
return;
IType type = types[j];
if (nameMatches(potentialMatchName, type, partialMatch)) {
seekQualifiedMemberTypes(name.substring(index + 1, name
.length()), type, partialMatch, requestor,
acceptFlags);
}
}
}
}
}
/**
* Remembers a set of compilation units that will be looked inside when
* looking up a type. If they are working copies, they take precedence of
* their compilation units. null means that no special
* compilation units should be used.
*/
// public void setUnitsToLookInside(IWorkingCopy[] unitsToLookInside) {
//
// if (unitsToLookInside == null) {
// this.unitsToLookInside.setCurrent(null);
// } else {
// HashMap workingCopies = new HashMap();
// this.unitsToLookInside.setCurrent(workingCopies);
// for (int i = 0, length = unitsToLookInside.length; i < length; i++) {
// IWorkingCopy unitToLookInside = unitsToLookInside[i];
// ICompilationUnit original = (ICompilationUnit) unitToLookInside
// .getOriginalElement();
// if (original != null) {
// workingCopies.put(original, unitToLookInside);
// } else {
// workingCopies.put(unitToLookInside, unitToLookInside);
// }
// }
// }
// }
/**
* Notifies the given requestor of all types (classes and interfaces) in the
* given type with the given (possibly qualified) name. Checks the requestor
* at regular intervals to see if the requestor has canceled.
*
* @param partialMatch
* partial name matches qualify when true, only
* exact name matches qualify when false
*/
protected void seekQualifiedMemberTypes(String qualifiedName, IType type,
boolean partialMatch, IJavaElementRequestor requestor,
int acceptFlags) {
if (type == null)
return;
IType[] types = null;
try {
types = type.getTypes();
} catch (JavaModelException npe) {
return; // the enclosing type is not present
}
String matchName = qualifiedName;
int index = qualifiedName.indexOf('$');
boolean nested = false;
if (index != -1) {
matchName = qualifiedName.substring(0, index);
nested = true;
}
int length = types.length;
for (int i = 0; i < length; i++) {
if (requestor.isCanceled())
return;
IType memberType = types[i];
if (nameMatches(matchName, memberType, partialMatch))
if (nested) {
seekQualifiedMemberTypes(qualifiedName.substring(index + 1,
qualifiedName.length()), memberType, partialMatch,
requestor, acceptFlags);
} else {
if (acceptType(memberType, acceptFlags))
requestor.acceptMemberType(memberType);
}
}
}
}