Example usage for org.eclipse.jdt.internal.core JavaProject computePackageFragmentRoots

Introduction

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

Prototype

public void computePackageFragmentRoots(IClasspathEntry resolvedEntry, ObjectVector accumulatedRoots,
        HashSet rootIDs, IClasspathEntry referringEntry, boolean retrieveExportedRoots,
        Map rootToResolvedEntries) throws JavaModelException 

Source Link

Document

Returns the package fragment roots identified by the given entry.

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/*from  www .  j  av a 2s.c om*/
 * @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));
    }
}

---

From source file:org.eclipse.xtext.common.types.access.jdt.JdtTypeProvider.java

License:Open Source License

/**
 * @see JavaProject#computePackageFragmentRoots(IClasspathEntry, ObjectVector, HashSet, IClasspathEntry, boolean, java.util.Map)
 *///  w ww  .  j a  va2  s.c om
private void collectSourcePackageFragmentRoots(JavaProject javaProject, HashSet<String> rootIDs,
        IClasspathEntry referringEntry, ObjectVector result) throws JavaModelException {
    if (referringEntry == null) {
        rootIDs.add(javaProject.rootID());
    } else if (rootIDs.contains(javaProject.rootID())) {
        return;
    }
    IWorkspaceRoot workspaceRoot = javaProject.getProject().getWorkspace().getRoot();
    for (IClasspathEntry entry : javaProject.getResolvedClasspath()) {
        switch (entry.getEntryKind()) {
        case IClasspathEntry.CPE_PROJECT:
            if (referringEntry != null && !entry.isExported())
                return;

            IPath pathToProject = entry.getPath();
            IResource referencedProject = workspaceRoot.findMember(pathToProject);
            if (referencedProject != null && referencedProject.getType() == IResource.PROJECT) {
                IProject casted = (IProject) referencedProject;
                if (JavaProject.hasJavaNature(casted)) {
                    rootIDs.add(javaProject.rootID());
                    JavaProject referencedJavaProject = (JavaProject) JavaCore.create(casted);
                    collectSourcePackageFragmentRoots(referencedJavaProject, rootIDs, entry, result);
                }
            }
            break;
        case IClasspathEntry.CPE_SOURCE:
            javaProject.computePackageFragmentRoots(entry, result, rootIDs, referringEntry, true, null);
            break;
        }
    }
}

---