Example usage for org.eclipse.jdt.internal.core JavaModel isFile

Introduction

In this page you can find the example usage for org.eclipse.jdt.internal.core JavaModel isFile.

Prototype

public static boolean isFile(Object target) 

Source Link

Document

Helper method - returns whether an object is a file (i.e., it returns true to File#isFile() .

Usage

From source file:org.eclipse.jdt.internal.core.JavaProject.java

License:Open Source License

/**
 * Returns the package fragment roots identified by the given entry. In case it refers to
 * a project, it will follow its classpath so as to find exported roots as well.
 * Only works with resolved entry// w w  w .ja  va2  s . co  m
 * @param resolvedEntry IClasspathEntry
 * @param accumulatedRoots ObjectVector
 * @param rootIDs HashSet
 * @param referringEntry the CP entry (project) referring to this entry, or null if initial project
 * @param retrieveExportedRoots boolean
 * @throws JavaModelException
 */
public void computePackageFragmentRoots(IClasspathEntry resolvedEntry, ObjectVector accumulatedRoots,
        HashSet rootIDs, IClasspathEntry referringEntry, boolean retrieveExportedRoots,
        Map rootToResolvedEntries) throws JavaModelException {

    String rootID = ((ClasspathEntry) resolvedEntry).rootID();
    if (rootIDs.contains(rootID))
        return;

    IPath projectPath = this.project.getFullPath();
    IPath entryPath = resolvedEntry.getPath();
    IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
    IPackageFragmentRoot root = null;

    switch (resolvedEntry.getEntryKind()) {

    // source folder
    case IClasspathEntry.CPE_SOURCE:

        if (projectPath.isPrefixOf(entryPath)) {
            Object target = JavaModel.getTarget(entryPath, true/*check existency*/);
            if (target == null)
                return;

            if (target instanceof IFolder || target instanceof IProject) {
                root = getPackageFragmentRoot((IResource) target);
            }
        }
        break;

    // internal/external JAR or folder
    case IClasspathEntry.CPE_LIBRARY:
        if (referringEntry != null && !resolvedEntry.isExported())
            return;
        Object target = JavaModel.getTarget(entryPath, true/*check existency*/);
        if (target == null)
            return;

        if (target instanceof IResource) {
            // internal target
            root = getPackageFragmentRoot((IResource) target, entryPath);
        } else if (target instanceof File) {
            // external target
            if (JavaModel.isFile(target)) {
                root = new JarPackageFragmentRoot(entryPath, this);
            } else if (((File) target).isDirectory()) {
                root = new ExternalPackageFragmentRoot(entryPath, this);
            }
        }
        break;

    // recurse into required project
    case IClasspathEntry.CPE_PROJECT:

        if (!retrieveExportedRoots)
            return;
        if (referringEntry != null && !resolvedEntry.isExported())
            return;

        IResource member = workspaceRoot.findMember(entryPath);
        if (member != null && member.getType() == IResource.PROJECT) {// double check if bound to project (23977)
            IProject requiredProjectRsc = (IProject) member;
            if (JavaProject.hasJavaNature(requiredProjectRsc)) { // special builder binary output
                rootIDs.add(rootID);
                JavaProject requiredProject = (JavaProject) JavaCore.create(requiredProjectRsc);
                requiredProject.computePackageFragmentRoots(requiredProject.getResolvedClasspath(),
                        accumulatedRoots, rootIDs,
                        rootToResolvedEntries == null ? resolvedEntry
                                : ((ClasspathEntry) resolvedEntry).combineWith((ClasspathEntry) referringEntry), // only combine if need to build the reverse map
                        retrieveExportedRoots, rootToResolvedEntries);
            }
            break;
        }
    }
    if (root != null) {
        accumulatedRoots.add(root);
        rootIDs.add(rootID);
        if (rootToResolvedEntries != null)
            rootToResolvedEntries.put(root,
                    ((ClasspathEntry) resolvedEntry).combineWith((ClasspathEntry) referringEntry));
    }
}

---