Example usage for org.eclipse.jdt.core IClasspathEntry CPE

Introduction

In this page you can find the example usage for org.eclipse.jdt.core IClasspathEntry CPE_VARIABLE.

Prototype

int CPE_VARIABLE

To view the source code for org.eclipse.jdt.core IClasspathEntry CPE_VARIABLE.

Click Source Link

Document

Entry kind constant describing a classpath entry defined using a path that begins with a classpath variable reference.

Usage

From source file:org.org.eclipse.dws.ui.internal.wizards.pages.LookupJavadocAndSourcesForLibrariesInClasspathPage.java

License:Open Source License

/**
 * Misses javadoc./*from  w  w  w . ja v  a2  s .  co m*/
 * 
 * @param packageFragmentRoot
 *            the package fragment root
 * 
 * @return true, if successful
 * 
 * @throws JavaModelException
 *             the java model exception
 */
private boolean missesJavadoc(IPackageFragmentRoot packageFragmentRoot) throws JavaModelException {
    int entryKind = packageFragmentRoot.getRawClasspathEntry().getEntryKind();
    boolean missesJavadoc = false;
    if (entryKind == IClasspathEntry.CPE_LIBRARY || entryKind == IClasspathEntry.CPE_VARIABLE) {
        missesJavadoc = JavaUI.getLibraryJavadocLocation(packageFragmentRoot.getRawClasspathEntry()) == null;
    }
    if (entryKind == IClasspathEntry.CPE_CONTAINER) {
        missesJavadoc = JavaUI.getJavadocLocation(packageFragmentRoot.getPrimaryElement(), false) == null;
    }
    return missesJavadoc;
}

From source file:org.seasar.diigu.eclipse.util.JavaProjectClassLoader.java

License:Apache License

protected void addClasspathEntries(IJavaProject project, Set already, boolean atFirst) {
    already.add(project);/* w ww  . java 2  s .c  o m*/

    try {
        IContainer workspaceroot = project.getProject().getParent();
        IPath path = project.getOutputLocation();
        addURL(toURL(workspaceroot.getFolder(path).getLocation()));

        IClasspathEntry[] entries = project.getResolvedClasspath(true);
        for (int i = 0; i < entries.length; i++) {
            IClasspathEntry entry = entries[i];
            switch (entry.getEntryKind()) {
            case IClasspathEntry.CPE_SOURCE:
                IPath dist = entry.getOutputLocation();
                if (dist != null) {
                    addURL(toURL(workspaceroot.getFolder(dist).getLocation()));
                }
                break;
            case IClasspathEntry.CPE_LIBRARY:
            case IClasspathEntry.CPE_CONTAINER:
            case IClasspathEntry.CPE_VARIABLE:
                IPath p = entry.getPath();
                if (p.toFile().exists()) {
                    addURL(toURL(p));
                } else {
                    addURL(toURL(workspaceroot.getFile(p).getLocation()));
                }
                break;
            case IClasspathEntry.CPE_PROJECT:
                IJavaProject proj = ProjectUtils.getJavaProject(entry.getPath().segment(0));
                if (proj != null && proj.exists() && already.contains(proj) == false
                        && (atFirst || entry.isExported())) {
                    addClasspathEntries(proj, already, false);
                }
                break;
            default:
                break;
            }
        }
    } catch (Exception e) {
        DiiguPlugin.log(e);
    }
}

From source file:org.seasar.kijimuna.core.util.JavaProjectClassLoader.java

License:Apache License

protected void addClasspathEntries(IJavaProject project, Set already, boolean atFirst) {
    already.add(project);//ww w.  j  av a  2 s  .  co  m

    try {
        IContainer workspaceroot = project.getProject().getParent();
        IPath path = project.getOutputLocation();
        addURL(toURL(workspaceroot.getFolder(path).getLocation()));

        IClasspathEntry[] entries = project.getResolvedClasspath(true);
        for (int i = 0; i < entries.length; i++) {
            IClasspathEntry entry = entries[i];
            switch (entry.getEntryKind()) {
            case IClasspathEntry.CPE_SOURCE:
                IPath dist = entry.getOutputLocation();
                if (dist != null) {
                    addURL(toURL(workspaceroot.getFolder(dist).getLocation()));
                }
                break;
            case IClasspathEntry.CPE_LIBRARY:
            case IClasspathEntry.CPE_CONTAINER:
            case IClasspathEntry.CPE_VARIABLE:
                IPath p = entry.getPath();
                if (p.toFile().exists()) {
                    addURL(toURL(p));
                } else {
                    addURL(toURL(workspaceroot.getFile(p).getLocation()));
                }
                break;
            case IClasspathEntry.CPE_PROJECT:
                IJavaProject proj = JavaCore.create(ProjectUtils.getProject(entry.getPath().segment(0)));
                if (proj != null && proj.exists() && already.contains(proj) == false
                        && (atFirst || entry.isExported())) {
                    addClasspathEntries(proj, already, false);
                }
                break;
            default:
                break;
            }
        }
    } catch (Exception e) {
        KijimunaCore.reportException(e);
    }
}

From source file:org.springframework.ide.eclipse.boot.properties.editor.StsConfigMetadataRepositoryJsonLoader.java

License:Open Source License

private String ekind(int ekind) {
    switch (ekind) {
    case IClasspathEntry.CPE_SOURCE:
        return "SRC";
    case IClasspathEntry.CPE_LIBRARY:
        return "LIB";
    case IClasspathEntry.CPE_PROJECT:
        return "PRJ";
    case IClasspathEntry.CPE_VARIABLE:
        return "VAR";
    case IClasspathEntry.CPE_CONTAINER:
        return "CON";
    default:/*from  w  w  w. ja v  a2  s .  c  o m*/
        return "" + ekind;
    }
}

From source file:org.wso2.developerstudio.eclipse.utils.jdt.JavaUtils.java

License:Open Source License

public static IPackageFragmentRoot[] getReferencedVariablesForProject(IProject project)
        throws JavaModelException {
    IJavaProject p = JavaCore.create(project);
    IPackageFragmentRoot[] packageFragmentRoots = p.getPackageFragmentRoots();
    ArrayList<IPackageFragmentRoot> jarClassPaths = new ArrayList<IPackageFragmentRoot>();
    for (IPackageFragmentRoot packageFragmentRoot : packageFragmentRoots) {
        if (packageFragmentRoot.getRawClasspathEntry().getEntryKind() == IClasspathEntry.CPE_VARIABLE) {
            jarClassPaths.add(packageFragmentRoot);
        }/*from w ww  . j  a  v a 2s  . c o m*/
    }
    return jarClassPaths.toArray(new IPackageFragmentRoot[] {});
}

From source file:org.wso2.developerstudio.eclipse.utils.jdt.JavaUtils.java

License:Open Source License

public static IPackageFragmentRoot[] getReferencedVariableLibrariesForProject(IProject project)
        throws JavaModelException {
    IJavaProject p = JavaCore.create(project);
    IPackageFragmentRoot[] packageFragmentRoots = p.getPackageFragmentRoots();
    ArrayList<IPackageFragmentRoot> jarClassPaths = new ArrayList<IPackageFragmentRoot>();
    for (IPackageFragmentRoot packageFragmentRoot : packageFragmentRoots) {
        if (isWebApp && packageFragmentRoot.isArchive()) {
            IClasspathEntry rawClasspathEntry = packageFragmentRoot.getRawClasspathEntry();
            IClasspathEntry resolvedClasspathEntry = JavaCore.getResolvedClasspathEntry(rawClasspathEntry);
            if (rawClasspathEntry.getEntryKind() == IClasspathEntry.CPE_VARIABLE
                    && resolvedClasspathEntry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
                jarClassPaths.add(packageFragmentRoot);
            }//from  w  w  w.  ja v  a 2s.c  o m
        } else if (!isWebApp) {
            IClasspathEntry rawClasspathEntry = packageFragmentRoot.getRawClasspathEntry();
            IClasspathEntry resolvedClasspathEntry = JavaCore.getResolvedClasspathEntry(rawClasspathEntry);
            if (rawClasspathEntry.getEntryKind() == IClasspathEntry.CPE_VARIABLE
                    && resolvedClasspathEntry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
                jarClassPaths.add(packageFragmentRoot);
            }
        }
    }
    return jarClassPaths.toArray(new IPackageFragmentRoot[] {});
}

From source file:repast.simphony.agents.designer.core.AgentBuilderPlugin.java

License:Open Source License

/**
 * Adds classpath entries to the supported list.
 * /*from   ww w .  j  ava 2  s .  com*/
 * @param projectName
 * @param pathEntries
 */
public static void getResolvedClasspath(String projectName, List pathEntries) {

    IJavaProject javaProject = AgentBuilderPlugin.getJavaProject(projectName);
    IPath path = null;
    try {
        IClasspathEntry[] entries = javaProject.getResolvedClasspath(true);
        for (int i = 0; i < entries.length; i++) {
            IClasspathEntry entry = entries[i];
            path = null;
            if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
                path = getWorkspaceRoot().getLocation()
                        .append(JavaCore.getResolvedClasspathEntry(entry).getPath());
            } else if (entry.getEntryKind() == IClasspathEntry.CPE_VARIABLE) {
                path = JavaCore.getResolvedClasspathEntry(entry).getPath();
            } else if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
                path = entry.getPath().makeAbsolute();
                if (!path.toFile().getAbsoluteFile().exists()) {
                    IPath location = getWorkspaceRoot().getProject(entry.getPath().segment(0))
                            .getFile(entry.getPath().removeFirstSegments(1)).getLocation();
                    if (location != null) {
                        File tmpFile = location.toFile();
                        if (tmpFile.exists())
                            path = location;
                    }
                }
            }
            if (path != null && !pathEntries.contains(path))
                pathEntries.add(path);

            if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) {
                IProject requiredProject = getWorkspaceProject(entry.getPath());
                // recurse into projects
                if (requiredProject != null)
                    getResolvedClasspath(requiredProject, pathEntries);
            }
        }
        IPath outputPath = javaProject.getOutputLocation();
        if (outputPath.segmentCount() == 1)
            outputPath = javaProject.getResource().getLocation();
        else
            outputPath = javaProject.getProject().getFile(outputPath.removeFirstSegments(1)).getLocation();
        if (outputPath != null && !pathEntries.contains(outputPath))
            pathEntries.add(outputPath);
    } catch (JavaModelException e) {
        AgentBuilderPlugin.log(e);
    }
}

From source file:runjettyrun.tabs.action.AddClassFolderAction.java

License:Open Source License

/**
 * Adds all exported entries defined by <code>proj</code> to the list
 * <code>runtimeEntries</code>.
 *
 * @param proj/*from  www .  j  ava 2  s. co m*/
 * @param runtimeEntries
 * @throws JavaModelException
 */
protected void collectExportedEntries(IJavaProject proj, List<IRuntimeClasspathEntry> runtimeEntries)
        throws CoreException {
    IClasspathEntry[] entries = proj.getRawClasspath();
    for (int i = 0; i < entries.length; i++) {
        IClasspathEntry entry = entries[i];
        if (entry.isExported()) {
            IRuntimeClasspathEntry rte = null;
            switch (entry.getEntryKind()) {
            case IClasspathEntry.CPE_CONTAINER:
                IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), proj);
                int kind = 0;
                switch (container.getKind()) {
                case IClasspathContainer.K_APPLICATION:
                    kind = IRuntimeClasspathEntry.USER_CLASSES;
                    break;
                case IClasspathContainer.K_SYSTEM:
                    kind = IRuntimeClasspathEntry.BOOTSTRAP_CLASSES;
                    break;
                case IClasspathContainer.K_DEFAULT_SYSTEM:
                    kind = IRuntimeClasspathEntry.STANDARD_CLASSES;
                    break;
                }
                rte = JavaRuntime.newRuntimeContainerClasspathEntry(entry.getPath(), kind, proj);
                break;
            case IClasspathEntry.CPE_LIBRARY:
                rte = JavaRuntime.newArchiveRuntimeClasspathEntry(entry.getPath());
                rte.setSourceAttachmentPath(entry.getSourceAttachmentPath());
                rte.setSourceAttachmentRootPath(entry.getSourceAttachmentRootPath());
                break;
            case IClasspathEntry.CPE_PROJECT:
                String name = entry.getPath().segment(0);
                IProject p = ResourcesPlugin.getWorkspace().getRoot().getProject(name);
                if (p.exists()) {
                    IJavaProject jp = JavaCore.create(p);
                    if (jp.exists()) {
                        rte = JavaRuntime.newProjectRuntimeClasspathEntry(jp);
                    }
                }
                break;
            case IClasspathEntry.CPE_VARIABLE:
                rte = JavaRuntime.newVariableRuntimeClasspathEntry(entry.getPath());
                break;
            default:
                break;
            }
            if (rte != null) {
                if (!runtimeEntries.contains(rte)) {
                    runtimeEntries.add(rte);
                }
            }
        }
    }
}

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());
            }/*from  w  w w .  java2  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;
        }
    }
}

Example usage for org.eclipse.jdt.core IClasspathEntry CPE_VARIABLE

Introduction

Prototype

Document

Usage