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

Introduction

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

Prototype

int CPE_LIBRARY

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

Click Source Link

Document

Entry kind constant describing a classpath entry identifying a library.

Usage

From source file:com.tasktop.dropwizard.launcher.DropwizardRuntimeClasspathProvider.java

License:Open Source License

protected void addProjectEntries(Set<IRuntimeClasspathEntry> resolved, IPath path, int scope, String classifier,
        ILaunchConfiguration launchConfiguration, final IProgressMonitor monitor) throws CoreException {
    IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
    IProject project = root.getProject(path.segment(0));

    IMavenProjectFacade projectFacade = projectManager.create(project, monitor);
    if (projectFacade == null) {
        return;/*from  w  ww  . j  a  v a  2s.co m*/
    }

    ResolverConfiguration configuration = projectFacade.getResolverConfiguration();
    if (configuration == null) {
        return;
    }

    IJavaProject javaProject = JavaCore.create(project);

    boolean projectResolved = false;

    for (IClasspathEntry entry : javaProject.getRawClasspath()) {
        IRuntimeClasspathEntry rce = null;
        switch (entry.getEntryKind()) {
        case IClasspathEntry.CPE_SOURCE:
            if (!projectResolved) {

                IMavenClassifierManager mavenClassifierManager = MavenJdtPlugin.getDefault()
                        .getMavenClassifierManager();
                IClassifierClasspathProvider classifierClasspathProvider = mavenClassifierManager
                        .getClassifierClasspathProvider(projectFacade, classifier);

                if (IClasspathManager.CLASSPATH_TEST == scope) {
                    classifierClasspathProvider.setTestClasspath(resolved, projectFacade, monitor);
                } else {
                    classifierClasspathProvider.setRuntimeClasspath(resolved, projectFacade, monitor);
                }

                projectResolved = true;
            }
            break;
        case IClasspathEntry.CPE_CONTAINER:
            IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), javaProject);
            if (container != null && !MavenClasspathHelpers.isMaven2ClasspathContainer(entry.getPath())) {
                switch (container.getKind()) {
                case IClasspathContainer.K_APPLICATION:
                    rce = JavaRuntime.newRuntimeContainerClasspathEntry(container.getPath(),
                            IRuntimeClasspathEntry.USER_CLASSES, javaProject);
                    break;
                default:
                    break;
                }
            }
            break;
        case IClasspathEntry.CPE_LIBRARY:
            rce = JavaRuntime.newArchiveRuntimeClasspathEntry(entry.getPath());
            break;
        case IClasspathEntry.CPE_VARIABLE:
            if (!JavaRuntime.JRELIB_VARIABLE.equals(entry.getPath().segment(0))) {
                rce = JavaRuntime.newVariableRuntimeClasspathEntry(entry.getPath());
            }
            break;
        case IClasspathEntry.CPE_PROJECT:
            IProject res = root.getProject(entry.getPath().segment(0));
            if (res != null) {
                IJavaProject otherProject = JavaCore.create(res);
                if (otherProject != null) {
                    rce = JavaRuntime.newDefaultProjectClasspathEntry(otherProject);
                }
            }
            break;
        default:
            break;
        }
        if (rce != null) {
            addStandardClasspathEntries(resolved, rce, launchConfiguration);
        }
    }
}

---

From source file:com.temenos.ds.op.xtext.ui.internal.se.JdtBasedProcessorProvider.java

License:Open Source License

protected URLClassLoader createClassLoaderForJavaProject(final IJavaProject projectToUse) {
    try {//from   w ww.  ja  v  a  2 s .c o m
        final IClasspathEntry[] resolvedClasspath = projectToUse.getResolvedClasspath(true);
        final List<URL> urls = CollectionLiterals.<URL>newArrayList();
        List<URL> _outputFolders = this.getOutputFolders(projectToUse);
        urls.addAll(_outputFolders);
        for (final IClasspathEntry entry : resolvedClasspath) {
            {
                URL url = null;
                int _entryKind = entry.getEntryKind();
                switch (_entryKind) {
                case IClasspathEntry.CPE_SOURCE:
                    break;
                case IClasspathEntry.CPE_PROJECT:
                    IPath path = entry.getPath();
                    IWorkspaceRoot _workspaceRoot = this.getWorkspaceRoot(projectToUse);
                    final IResource project = _workspaceRoot.findMember(path);
                    IProject _project = project.getProject();
                    IJavaProject _create = JavaCore.create(_project);
                    List<URL> _outputFolders_1 = this.getOutputFolders(_create);
                    urls.addAll(_outputFolders_1);
                    break;
                case IClasspathEntry.CPE_LIBRARY:
                    IPath path_1 = entry.getPath();
                    IWorkspaceRoot _workspaceRoot_1 = this.getWorkspaceRoot(projectToUse);
                    final IResource library = _workspaceRoot_1.findMember(path_1);
                    URL _xifexpression = null;
                    boolean _notEquals = (!Objects.equal(library, null));
                    if (_notEquals) {
                        URI _rawLocationURI = library.getRawLocationURI();
                        _xifexpression = _rawLocationURI.toURL();
                    } else {
                        File _file = path_1.toFile();
                        URI _uRI = _file.toURI();
                        _xifexpression = _uRI.toURL();
                    }
                    url = _xifexpression;
                    break;
                default: {
                    IPath path_2 = entry.getPath();
                    File _file_1 = path_2.toFile();
                    URI _uRI_1 = _file_1.toURI();
                    URL _uRL = _uRI_1.toURL();
                    url = _uRL;
                }
                    break;
                }
                boolean _notEquals_1 = (!Objects.equal(url, null));
                if (_notEquals_1) {
                    urls.add(url);
                }
            }
        }
        ClassLoader _parentClassLoader = this.getParentClassLoader();
        return new URLClassLoader(((URL[]) Conversions.unwrapArray(urls, URL.class)), _parentClassLoader);
    } catch (Throwable _e) {
        throw Exceptions.sneakyThrow(_e);
    }
}

---

From source file:com.windowtester.eclipse.ui.convert.WTAPIUsage.java

License:Open Source License

private void collectPluginsReferencedByClasspathEntry(PrintWriter writer, Collection<String> pluginIds,
        IJavaProject proj, IClasspathEntry entry) throws IOException {
    IPath path = entry.getPath();//from w  w w .j  a v  a 2  s  .  com
    switch (entry.getEntryKind()) {

    case IClasspathEntry.CPE_LIBRARY:
    case IClasspathEntry.CPE_VARIABLE:
        for (int i = path.segmentCount() - 1; i >= 0; i--) {
            String segment = path.segment(i);
            if (segment.startsWith("com.windowtester.")) {
                String id = segment;
                i++;
                while (i < path.segmentCount())
                    id += "/" + path.segment(i++);
                pluginIds.add(id);
                break;
            }
        }
        break;

    case IClasspathEntry.CPE_CONTAINER:
        if (path.segmentCount() >= 1 && path.segment(0).equals("org.eclipse.pde.core.requiredPlugins"))
            collectPluginsReferencedInManifest(pluginIds, proj);
        break;

    case IClasspathEntry.CPE_SOURCE:
    case IClasspathEntry.CPE_PROJECT:
        // ignored
        break;

    default:
        pluginIds.add("unknown " + entry.getEntryKind() + " - " + entry);
        break;
    }
}

---

From source file:copied.org.eclipse.pde.internal.launching.sourcelookup.PDESourceLookupParticipant.java

License:Open Source License

private void addProjectSourceContainers(IProject project, ArrayList<IRuntimeClasspathEntry> result)
        throws CoreException {
    if (project == null || !project.hasNature(JavaCore.NATURE_ID))
        return;/* w w w .jav  a 2  s. co  m*/

    IJavaProject jProject = JavaCore.create(project);
    result.add(JavaRuntime.newProjectRuntimeClasspathEntry(jProject));

    IClasspathEntry[] entries = jProject.getRawClasspath();
    for (int i = 0; i < entries.length; i++) {
        IClasspathEntry entry = entries[i];
        if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
            IRuntimeClasspathEntry rte = convertClasspathEntry(entry);
            if (rte != null)
                result.add(rte);
        }
    }

    // Add additional entries from contributed classpath container resolvers
    IBundleClasspathResolver[] resolvers = PDECore.getDefault().getClasspathContainerResolverManager()
            .getBundleClasspathResolvers(project);
    for (int i = 0; i < resolvers.length; i++) {
        result.addAll(resolvers[i].getAdditionalSourceEntries(jProject));
    }
}

---

From source file:de.ovgu.featureide.core.framework.FrameworkComposer.java

License:Open Source License

/**
 * Update .classpath file//  ww w .ja  va 2 s. co  m
 * 
 * @param project
 */
private void setBuildpaths(IProject project) {

    try {
        final IJavaProject javaProject = JavaCore.create(project);
        final IClasspathEntry[] oldEntries = javaProject.getRawClasspath();
        final List<IClasspathEntry> entries = new ArrayList<IClasspathEntry>();
        /** copy existing non-feature entries **/
        for (int i = 0; i < oldEntries.length; i++) {
            if (oldEntries[i].getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
                final IPath path = oldEntries[i].getPath();
                if (!isFeatureLib(path)) {
                    entries.add(oldEntries[i]);
                }
            } else {
                entries.add(oldEntries[i]);
            }
        }

        /** add selected features **/
        try {
            for (final IResource res : getJarFolder().members()) {
                final String featureName = res.getName();
                if (selectedFeatures.contains(featureName)) {
                    final List<IPath> newEntries = createNewIPath(res);
                    for (final IPath entry : newEntries) {
                        final IClasspathEntry newLibraryEntry = JavaCore.newLibraryEntry(entry, null, null);
                        entries.add(newLibraryEntry);
                    }
                }
            }
        } catch (final CoreException e) {
            FrameworkCorePlugin.getDefault().logError(e);
        }

        final IClasspathEntry[] result = entries.toArray(new IClasspathEntry[0]);
        javaProject.setRawClasspath(result, null);
    } catch (final JavaModelException e) {
        FrameworkCorePlugin.getDefault().logError(e);
    }
}

---

From source file:de.ovgu.featureide.migration.impl.DefaultSPLMigrator.java

License:Open Source License

/**
 * @param newJavaProject//from w w w  . j a  v a2 s.co  m
 * @param classpathToMigrate
 * @param newClassPath
 * @throws JavaModelException
 */
private void migrateLibraryAndContainerEntries(JavaProject newJavaProject, IClasspathEntry[] classpathToMigrate,
        List<IClasspathEntry> newClassPath) throws JavaModelException {
    for (IClasspathEntry entry : classpathToMigrate) {
        if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER
                || entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY)
            if (!newClassPath.contains(entry))
                newClassPath.add(entry);
    }
    newJavaProject.setRawClasspath(newClassPath.toArray(new IClasspathEntry[newClassPath.size()]), null);
}

---

From source file:de.ovgu.featureide.ui.actions.generator.Generator.java

License:Open Source License

/**
 * Sets the classpath entries for the newly created project
 * @param p The new project/*from www  . j  a v  a 2s.  c o  m*/
 */
// TODO remove redundant calculations for each configuration
// TODO copy settings
private void setClassPath(IProject p) {
    JavaProject baseProject = new JavaProject(builder.featureProject.getProject(), null);
    JavaProject newProject = new JavaProject(p, null);
    try {
        IClasspathEntry[] entries = baseProject.getRawClasspath().clone();
        for (int i = 0; i < entries.length; i++) {
            // set source entry to "src"
            IClasspathEntry e = entries[i];
            if (entries[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) {
                entries[i] = new ClasspathEntry(e.getContentKind(), e.getEntryKind(), new Path("src"),
                        e.getInclusionPatterns(), e.getExclusionPatterns(), e.getSourceAttachmentPath(),
                        e.getSourceAttachmentRootPath(), null, e.isExported(), e.getAccessRules(),
                        e.combineAccessRules(), e.getExtraAttributes());
            } else if (e.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
                // set the library entries and copy the libraries 
                // which are direct at the old projects folder  
                IPath path = e.getPath().removeFirstSegments(1);
                IProject project = builder.featureProject.getProject();
                IFile file = project.getFile(path);
                if (!file.exists()) {
                    path = e.getPath();
                    file = project.getFile(path);
                    if (!file.exists()) {
                        continue;
                    }
                }
                createLibFolder(p.getFile(path).getParent());
                file.copy(p.getFile(e.getPath().removeFirstSegments(1)).getFullPath(), true, null);
                entries[i] = new ClasspathEntry(e.getContentKind(), e.getEntryKind(),
                        e.getPath().removeFirstSegments(1), e.getInclusionPatterns(), e.getExclusionPatterns(),
                        e.getSourceAttachmentPath(), e.getSourceAttachmentRootPath(), null, e.isExported(),
                        e.getAccessRules(), e.combineAccessRules(), e.getExtraAttributes());
            }
        }
        newProject.setRawClasspath(entries, null);
    } catch (JavaModelException e) {
        UIPlugin.getDefault().logError(e);
    } catch (CoreException e) {
        UIPlugin.getDefault().logError(e);
    }
}

---

From source file:de.tobject.findbugs.builder.PDEClassPathGenerator.java

License:Open Source License

@SuppressWarnings("restriction")
private static Set<String> createJavaClasspath(IJavaProject javaProject, Set<IProject> projectOnCp) {
    LinkedHashSet<String> classPath = new LinkedHashSet<String>();
    try {/* w  ww  . j  a va  2 s.com*/
        // doesn't return jre libraries
        String[] defaultClassPath = JavaRuntime.computeDefaultRuntimeClassPath(javaProject);
        for (String classpathEntry : defaultClassPath) {
            IPath path = new Path(classpathEntry);
            if (isValidPath(path)) {
                classPath.add(path.toOSString());
            }
        }
        // add CPE_CONTAINER classpathes
        IClasspathEntry[] rawClasspath = javaProject.getRawClasspath();
        for (IClasspathEntry entry : rawClasspath) {
            if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
                IClasspathContainer classpathContainer = JavaCore.getClasspathContainer(entry.getPath(),
                        javaProject);
                if (classpathContainer != null) {
                    if (classpathContainer instanceof JREContainer) {
                        IClasspathEntry[] classpathEntries = classpathContainer.getClasspathEntries();
                        for (IClasspathEntry iClasspathEntry : classpathEntries) {
                            IPath path = iClasspathEntry.getPath();
                            // smallest possible fix for #1228 Eclipse plugin always uses host VM to resolve JDK classes
                            if (isValidPath(path) && "rt.jar".equals(path.lastSegment())) {
                                classPath.add(path.toOSString());
                                break;
                            }
                        }
                    } else {
                        IClasspathEntry[] classpathEntries = classpathContainer.getClasspathEntries();
                        for (IClasspathEntry classpathEntry : classpathEntries) {
                            IPath path = classpathEntry.getPath();
                            // shortcut for real files
                            if (classpathEntry.getEntryKind() == IClasspathEntry.CPE_LIBRARY
                                    && isValidPath(path)) {
                                classPath.add(path.toOSString());
                            } else {
                                resolveInWorkspace(classpathEntry, classPath, projectOnCp);
                            }
                        }
                    }
                }
            }
        }
    } catch (CoreException e) {
        FindbugsPlugin.getDefault().logException(e,
                "Could not compute aux. classpath for project " + javaProject);
    }
    return classPath;
}

---

From source file:de.tobject.findbugs.builder.PDEClassPathGenerator.java

License:Open Source License

private static void resolveInWorkspace(IClasspathEntry classpathEntry, Set<String> classPath,
        Set<IProject> projectOnCp) {
    int entryKind = classpathEntry.getEntryKind();
    switch (entryKind) {
    case IClasspathEntry.CPE_PROJECT:
        Set<String> cp = resolveProjectClassPath(classpathEntry.getPath(), projectOnCp);
        classPath.addAll(cp);// w ww .  j av a2  s. c  o  m
        break;
    case IClasspathEntry.CPE_VARIABLE:
        classpathEntry = JavaCore.getResolvedClasspathEntry(classpathEntry);
        if (classpathEntry == null) {
            return;
        }
        //$FALL-THROUGH$
    case IClasspathEntry.CPE_LIBRARY:
        String lib = resolveLibrary(classpathEntry.getPath());
        if (lib != null) {
            classPath.add(lib);
        }
        break;
    case IClasspathEntry.CPE_SOURCE:
        // ???
        break;
    default:
        break;
    }
}

---

From source file:dynamicrefactoring.integration.ModelGenerator.java

License:Open Source License

/**
 * Realiza la carga de bibliotecas bsicas del API de Java.
 * //from   w  ww  . j  a  v a 2s . c  o  m
 * Es un paso previo necesario para poder utilizar las clases de dichos
 * paquetes en las clases a partir de las cuales se quiere generar un modelo.
 * 
 * @throws Exception si se produce un error al acceder a los ficheros JAR
 * que se supone contienen las bibliotecas.
 */
private void loadBasicLibraries() throws Exception {

    String JRE_root = JavaRuntime.getVMInstall(project).getInstallLocation().getAbsolutePath();

    BinaryLoader binaryLoader = new BinaryLoader();

    String rtPath = null;

    IClasspathEntry[] classpath = project.getResolvedClasspath(true);
    for (int i = 0; i < classpath.length; i++) {
        if (classpath[i].getEntryKind() == IClasspathEntry.CPE_LIBRARY
                && classpath[i].getContentKind() == IPackageFragmentRoot.K_BINARY) {
            IPath path = classpath[i].getPath();
            if (path.toOSString().endsWith(BASIC_JAR)) {
                rtPath = path.toOSString();
                // Se aaden el resto de bibliotecas de forma normal.
            } else if (path.toOSString().toLowerCase().endsWith(LIB_EXTENSION))
                // Salvo las que pertenezcan al JRE o el JDK.
                if (!path.toOSString().startsWith(JRE_root)) {
                    // Si la ruta no es relativa al proyecto.
                    if (!path.toOSString().startsWith(project.getPath().toOSString())) {
                        binaryLoader.addClassesFromJar(path.toOSString());
                        // Para las rutas relativas al proyecto.
                    } else {
                        String relativePath = path.removeFirstSegments(1).toOSString();
                        if (project.getJavaProject().getResource() != null) {
                            String projectPath = project.getJavaProject().getResource().getLocation()
                                    .toOSString();
                            binaryLoader.addClassesFromJar(projectPath + File.separatorChar + //$NON-NLS-1$
                                    relativePath);
                        }
                    }
                }
        }
    }

    if (rtPath == null) {
        rtPath = JRE_root + File.separatorChar + BASIC_JAR; //$NON-NLS-1$
    }

    binaryLoader.addClassesFromJar(rtPath);

    //for (int i = 0; i < LIBRARIES.length; i++)
    //   binaryLoader.addClassesFromPackageInJar(LIBRARIES[i], rtPath);

    binaryLoader.load();
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• »