Example usage for org.eclipse.jdt.core IPackageFragmentRoot isExternal

List of usage examples for org.eclipse.jdt.core IPackageFragmentRoot isExternal

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.*
  5. IPackageFragmentRoot
  6. isExternal

Introduction

In this page you can find the example usage for org.eclipse.jdt.core IPackageFragmentRoot isExternal.

Prototype

boolean isExternal();

Source Link

Document

Returns whether this package fragment root is external to the workbench (that is, a local file), and has no underlying resource.

Usage

From source file:org.eclipse.xtext.ui.util.JdtClasspathUriResolver.java

License:Open Source License

protected URI findResourceInWorkspace(IJavaProject javaProject, URI classpathUri) throws CoreException {
    if (javaProject.exists()) {
        String packagePath = classpathUri.trimSegments(1).path();
        String fullPath = classpathUri.path();
        String fileName = classpathUri.lastSegment();
        IPath filePath = new Path(fileName);
        String packageName = isEmpty(packagePath) ? "" : packagePath.substring(1).replace('/', '.');
        for (IPackageFragmentRoot packageFragmentRoot : javaProject.getAllPackageFragmentRoots()) {
            IPackageFragment packageFragment = packageFragmentRoot.getPackageFragment(packageName);
            if (packageFragment.exists()) {
                IResource packageFragmentResource = packageFragment.getResource();
                if (packageFragmentResource instanceof IContainer) {
                    IFile file = ((IContainer) packageFragmentResource).getFile(filePath);
                    if (file.exists())
                        return createPlatformResourceURI(file);
                } else { // jar file or external class folder
                    if (packageFragmentRoot.isArchive()) { // jar file
                        Object[] nonJavaResources = getNonJavaResources(packageFragmentRoot, packageFragment);
                        for (Object nonJavaResource : nonJavaResources) {
                            IJarEntryResource jarEntryResource = (IJarEntryResource) nonJavaResource;
                            if (fullPath.equals(jarEntryResource.getFullPath().toString())) {
                                IResource packageFragmentRootResource = packageFragmentRoot.getResource();
                                if (packageFragmentRootResource != null) { // we have a resource - use nested platform/resource
                                    URI packageFragmentRootURI = createPlatformResourceURI(
                                            packageFragmentRootResource);
                                    URI result = createArchiveURI(packageFragmentRootURI, fullPath);
                                    return result;
                                } else {
                                    // no resource - use file uri
                                    IPath packageFragmentRootPath = packageFragmentRoot.getPath();
                                    URI packageFragmentRootURI = URI
                                            .createFileURI(packageFragmentRootPath.toString());
                                    URI result = createArchiveURI(packageFragmentRootURI, fullPath);
                                    return result;
                                }//w ww .jav a 2  s. c  om
                            }
                        }
                    } else if (packageFragmentRoot.isExternal()) { // external class folder
                        Object[] nonJavaResources = getNonJavaResources(packageFragmentRoot, packageFragment);
                        for (Object nonJavaResource : nonJavaResources) {
                            IJarEntryResource jarEntryResource = (IJarEntryResource) nonJavaResource;
                            if (fileName.equals(jarEntryResource.getName())) {
                                IResource packageFragmentRootResource = ((ExternalPackageFragmentRoot) packageFragmentRoot)
                                        .resource();
                                IPath absolutePath = packageFragmentRootResource.getFullPath();
                                absolutePath = absolutePath.append(fullPath);
                                return createPlatformResourceURI(absolutePath);
                            }
                        }
                    }
                }
            }
        }
        // not found in a source folder - look for a resource relative to project root
        // of this project or one of its dependencies
        URI result = findResourceInProjectRoot(javaProject, classpathUri.path(), Sets.<String>newHashSet());
        if (result != null) {
            return result;
        }
    }
    return classpathUri;
}

From source file:org.fastcode.util.SourceUtil.java

License:Open Source License

/**
 *
 * @param project//from  ww w  .  j a va 2s. c  o m
 * @return
 */
public static String[][] getSourcePathsForProject(final String project) {
    final IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();

    final List<String> paths = new ArrayList<String>();
    try {
        for (final IProject prjct : projects) {
            if (project == null || prjct.getName().equals(project)) {
                final IJavaProject javaProject = JavaCore.create(prjct);
                if (javaProject == null || !javaProject.exists()) {
                    continue;
                }
                if (isProjectBinary(javaProject)) {
                    continue;
                }
                for (final IPackageFragmentRoot packageFragmentRoot : javaProject
                        .getAllPackageFragmentRoots()) {
                    if (packageFragmentRoot == null || !packageFragmentRoot.exists()
                            || packageFragmentRoot.isArchive() || packageFragmentRoot.isExternal()) {
                        continue;
                    }
                    if (!packageFragmentRoot.getParent().equals(javaProject)) { // discard
                        // roots
                        // which
                        // come
                        // from
                        // another
                        // project.
                        continue;
                    }
                    final String fullSrcPath = packageFragmentRoot.getPath().toString();
                    final String srcPath = fullSrcPath
                            .replaceFirst(FORWARD_SLASH + javaProject.getElementName(), EMPTY_STR);
                    if (!paths.contains(srcPath)) {
                        paths.add(srcPath);
                    }
                }
            }
        }
    } catch (final Exception ex) {
        ex.printStackTrace();
    }

    return getStringArrayFromList(paths, true);
}

From source file:org.jboss.tools.ws.jaxrs.core.internal.metamodel.builder.JavaElementDeltaScanner.java

License:Open Source License

/**
 * Recursively analyse the given Java Element Delta.
 * /*from ww  w . jav  a  2 s .c  o m*/
 * @param delta
 * @param eventType
 * @throws CoreException
 * @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=100267
 */
private List<JavaElementChangedEvent> scanDelta(final IJavaElementDelta delta, final int eventType)
        throws CoreException {
    final List<JavaElementChangedEvent> events = new ArrayList<JavaElementChangedEvent>();
    final IJavaElement element = delta.getElement();
    // skip as the project is closed
    if (element == null) {
        Logger.debug("** skipping this build because the delta element is null **");
        return Collections.emptyList();
    } else if (element.getElementType() == IJavaElement.JAVA_PROJECT
            && !element.getJavaProject().getProject().isOpen() && delta.getFlags() != F_OPENED) {
        Logger.debug("** skipping this build because the java project is closed. **");
        return Collections.emptyList();
    } else if ((element.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT)) {
        final IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot) element;
        if (!packageFragmentRoot.isExternal()
                && (packageFragmentRoot.getResource() == null || !packageFragmentRoot.getResource().exists())) {
            return Collections.emptyList();
        }
    } else if (element.getResource() == null || !element.getResource().exists()) {
        return Collections.emptyList();
    }
    final int elementKind = element.getElementType();
    final int deltaKind = retrieveDeltaKind(delta);
    final Flags flags = new Flags(delta.getFlags());
    if (elementKind == JAVA_PROJECT) {
        final JavaElementChangedEvent event = new JavaElementChangedEvent(element, delta.getKind(), eventType,
                null, new Flags(delta.getFlags()));
        if (javaElementChangedEventFilter.apply(event)) {
            events.add(event);
            // skip anything below
            return events;
        }
    }
    final CompilationUnit compilationUnitAST = getCompilationUnitAST(delta);
    if (elementKind == COMPILATION_UNIT) {
        final ICompilationUnit compilationUnit = (ICompilationUnit) element;
        // compilationUnitAST is null when the given compilation unit'w
        // working copy is being commited (ie, Java Editor is being closed
        // for the given compilation unit, etc.)
        if (compilationUnit.exists() // see https://issues.jboss.org/browse/JBIDE-12760: compilationUnit may not exist
                && compilationUnit.isWorkingCopy() && compilationUnitAST != null) {
            // assuming possible changes in the method signatures (return type,
            // param types and param annotations). Other changes in methods
            // (renaming, adding/removing params) result in add+remove
            // events on the given method itself.
            if (requiresDiffsComputation(flags)) {
                for (IType type : compilationUnit.getAllTypes()) {
                    for (IMethod javaMethod : type.getMethods()) {
                        final JavaElementChangedEvent event = new JavaElementChangedEvent(javaMethod, CHANGED,
                                eventType, compilationUnitAST, new Flags(F_SIGNATURE));
                        if (javaElementChangedEventFilter.apply(event)) {
                            events.add(event);
                        }
                    }
                }
            }
        }
    }
    // element is part of the compilation unit
    else if (compilationUnitAST != null) {
        final JavaElementChangedEvent event = new JavaElementChangedEvent(element, deltaKind, eventType,
                compilationUnitAST, flags);
        if (javaElementChangedEventFilter.apply(event)) {
            events.add(event);
        }
    }
    // continue with children elements, both on annotations and other java
    // elements.
    for (IJavaElementDelta affectedChild : delta.getAffectedChildren()) {
        events.addAll(scanDelta(affectedChild, eventType));
    }
    for (IJavaElementDelta annotation : delta.getAnnotationDeltas()) {
        events.addAll(scanDelta(annotation, eventType));
    }
    return events;
}

From source file:org.summer.dsl.builder.impl.javasupport.ProjectClasspathChangeListener.java

License:Open Source License

protected Set<IJavaProject> getJavaProjectsWithClasspathChange(IJavaElementDelta delta) {
    IJavaElement element = delta.getElement();
    if (element instanceof IPackageFragmentRoot) {
        IPackageFragmentRoot root = (IPackageFragmentRoot) element;
        if (delta.getKind() == IJavaElementDelta.REMOVED || delta.getKind() == IJavaElementDelta.ADDED
                || (delta.getFlags() & IJavaElementDelta.F_REORDER) != 0
                || (delta.getFlags() & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) != 0
                || (delta.getFlags() & IJavaElementDelta.F_ADDED_TO_CLASSPATH) != 0
                || (root.isExternal() && (delta.getFlags() & // external folders change
                        (IJavaElementDelta.F_CONTENT | IJavaElementDelta.F_SOURCEATTACHED
                                | IJavaElementDelta.F_SOURCEDETACHED)) == delta.getFlags())) {
            return Collections.singleton(root.getJavaProject());
        }//from w  ww .ja v  a 2s .  co  m
    } else if (element instanceof IJavaModel) {
        return getPackageFragmentRootDeltas(delta.getAffectedChildren());
    } else if (element instanceof IJavaProject) {
        if ((delta.getFlags() & IJavaElementDelta.F_CLASSPATH_CHANGED) != 0
                || (delta.getFlags() & IJavaElementDelta.F_RESOLVED_CLASSPATH_CHANGED) != 0)
            return Collections.singleton((IJavaProject) element);
        return getPackageFragmentRootDeltas(delta.getAffectedChildren());
    }
    return Collections.emptySet();
}

From source file:org.switchyard.tools.ui.SwitchYardModelUtils.java

License:Open Source License

/**
 * Return the corresponding resource for the resource path.
 * //from www.  j av a2s. c  o m
 * @param project the project containing the resource (or reference)
 * @param resourcePath the location relative to the project's classpath
 * @return the corresponding resource.
 */
public static IResource getJavaResource(IProject project, String resourcePath) {
    if (project == null || resourcePath == null || resourcePath.length() == 0) {
        return null;
    }

    IJavaProject jp = JavaCore.create(project);
    if (jp == null) {
        return null;
    }
    resourcePath = URI.create(resourcePath).getPath();
    try {
        for (IPackageFragmentRoot pfr : jp.getAllPackageFragmentRoots()) {
            if (pfr.isArchive() || pfr.isExternal()) {
                continue;
            }
            final IPath path = pfr.getPath().append(resourcePath);
            IFile file = project.getWorkspace().getRoot().getFile(path);
            if (file.exists()) {
                return file;
            }
        }
    } catch (JavaModelException e) {
        return null;
    }
    return null;
}

From source file:x10dt.search.core.pdb.X10FactGenerator.java

License:Open Source License

private void processEntries(final CompilerOptionsBuilder cmpOptBuilder, final IWorkspaceRoot wsRoot,
        final IClasspathEntry[] entries, final IJavaProject javaProject, final IResource contextResource,
        final boolean isInRuntime) throws JavaModelException, AnalysisException {
    for (final IClasspathEntry pathEntry : entries) {
        switch (pathEntry.getEntryKind()) {
        case IClasspathEntry.CPE_SOURCE:
            if (pathEntry.getPath().isRoot()) {
                cmpOptBuilder.addToSourcePath(pathEntry.getPath().toFile());
            } else {
                cmpOptBuilder.addToSourcePath(wsRoot.getLocation().append(pathEntry.getPath()).toFile());
            }// w  w w . ja v a  2  s.  c  om
            if (pathEntry.getPath().segmentCount() > 1) {
                processSourceFolder(cmpOptBuilder, wsRoot.getFolder(pathEntry.getPath()), contextResource);
            }
            break;

        case IClasspathEntry.CPE_LIBRARY:
            try {
                final IPackageFragmentRoot pkgRoot = javaProject.findPackageFragmentRoot(pathEntry.getPath());
                if ((pkgRoot != null) && pkgRoot.exists()) {
                    final File localFile;
                    if (pkgRoot.isExternal()) {
                        localFile = pathEntry.getPath().toFile();
                    } else {
                        localFile = pkgRoot.getResource().getLocation().toFile();
                    }
                    cmpOptBuilder.addToClassPath(localFile.getAbsolutePath());
                    if (isInRuntime) {
                        cmpOptBuilder.addToSourcePath(localFile);
                    }
                    final ZipFile zipFile;
                    if (JAR_EXT.equals(pathEntry.getPath().getFileExtension())) {
                        zipFile = new JarFile(localFile);
                    } else {
                        zipFile = new ZipFile(localFile);
                    }
                    processLibrary(cmpOptBuilder, zipFile, localFile, contextResource, isInRuntime);
                }
            } catch (IOException except) {
                throw new AnalysisException(NLS.bind(Messages.XFG_JarReadingError, pathEntry.getPath()),
                        except);
            }
            break;

        case IClasspathEntry.CPE_CONTAINER:
            final IClasspathContainer cpContainer = JavaCore.getClasspathContainer(pathEntry.getPath(),
                    javaProject);
            processEntries(cmpOptBuilder, wsRoot, cpContainer.getClasspathEntries(), javaProject,
                    contextResource, true);
            break;

        case IClasspathEntry.CPE_PROJECT:
            final IResource projectResource = ResourcesPlugin.getWorkspace().getRoot()
                    .findMember(pathEntry.getPath());
            if ((projectResource != null) && projectResource.isAccessible()) {
                final IJavaProject newJavaProject = JavaCore.create((IProject) projectResource);
                processEntries(cmpOptBuilder, wsRoot, newJavaProject.getRawClasspath(), newJavaProject,
                        contextResource, false);
            }
            break;

        case IClasspathEntry.CPE_VARIABLE:
            processEntries(cmpOptBuilder, wsRoot,
                    new IClasspathEntry[] { JavaCore.getResolvedClasspathEntry(pathEntry) }, javaProject,
                    contextResource, false);
            break;
        }
    }
}