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

Introduction

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

Prototype

int CPE_CONTAINER

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

Click Source Link

Document

Entry kind constant describing a classpath entry representing a name classpath container.

Usage

From source file:me.gladwell.eclipse.m2e.android.test.AndroidMavenPluginTestCase.java

License:Open Source License

protected IClasspathEntry getClasspathContainer(IJavaProject javaProject, String id) throws JavaModelException {
    for (IClasspathEntry entry : javaProject.getRawClasspath()) {
        if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
            if (entry.getPath().toOSString().equals(id)) {
                return entry;
            }/*from w w  w .ja  va  2  s.c  om*/
        }
    }
    return null;
}

---

From source file:net.kbserve.pyjdt.properties.models.CPEAbstractContainer.java

License:Open Source License

/**
 * Update the list of children to include the ICPEType contains the giveb IClasspathEntry
 * //from ww w .j av a2  s. c  o m
 * @param child
 *            the child
 * @param project
 *            the project
 * @return the iCPE type
 */
public synchronized ICPEType updateChild(IClasspathEntry child, IProject project) {

    String stringPath = makeStringPath(child.getPath());
    ICPEType icp = getChild(stringPath);
    if (icp == null) {
        switch (child.getEntryKind()) {
        case (IClasspathEntry.CPE_CONTAINER):
            icp = new CPEContainer();
            break;
        case (IClasspathEntry.CPE_LIBRARY):
            icp = new CPELibrary();
            break;
        case (IClasspathEntry.CPE_PROJECT):
            icp = new CPEProject();
            break;
        case (IClasspathEntry.CPE_SOURCE):
            icp = new CPESource();
            break;
        case (IClasspathEntry.CPE_VARIABLE):
            icp = new CPEVariable();
            break;
        default:
            throw new UnsupportedOperationException(
                    "Unsupported IClasspathEntry.getEntryKind() = '" + child.getEntryKind() + "' on " + child);
        }
        children.add(icp);
        icp.setPath(stringPath);
        icp.setParent(this.getPath());
    }

    return icp;
}

---

From source file:net.rim.ejde.internal.packaging.PackagingManager.java

License:Open Source License

static private void getCompileImportsRecusively(IClasspathEntry[] entries, IJavaProject jProject,
        Vector<ImportedJar> imports, boolean isMainProject) throws CoreException {
    if (imports == null) {
        imports = new Vector<ImportedJar>();
    }/*from   w  w w .j  a  v a2  s .c o m*/
    // Workspace imports; if there aren't any specified, default to
    // using the runtime libraries.
    IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
    // String jarPathString;
    try {
        BlackBerryProperties properties = null;
        boolean needAddBBJar = false;
        IPath jarPath = null;
        ImportedJar importedJar = null;
        for (IClasspathEntry entry : entries) {
            switch (entry.getEntryKind()) {
            case IClasspathEntry.CPE_CONTAINER: {
                // libraries
                IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(),
                        jProject.getJavaProject());
                if (container == null) {
                    continue;
                }

                IVMInstall containerVM;
                if (!(container instanceof JREContainer)) {
                    // We need to verify the type of the container because the path of Maven container only has one
                    // segment and JavaRuntime.getVMInstall(IPath) return the default VM install if the entry path has one
                    // segment.
                    containerVM = null;
                } else {
                    containerVM = JavaRuntime.getVMInstall(entry.getPath());
                }

                try {
                    if (containerVM != null) {
                        if (containerVM.getVMInstallType().getId().equals(BlackBerryVMInstallType.VM_ID)) {
                            if (isMainProject) {
                                // Add jars to a list
                                IClasspathEntry[] classpathEntries = container.getClasspathEntries();
                                if (classpathEntries != null && classpathEntries.length > 0) {
                                    getCompileImportsRecusively(classpathEntries, jProject, imports, false);
                                }
                            }
                        } else {
                            if (!jProject.getProject().hasNature(BlackBerryProjectCoreNature.NATURE_ID)) {
                                needAddBBJar = true;
                                continue;
                            }
                        }
                    } else {
                        // Add jars to a list
                        IClasspathEntry[] classpathEntries = container.getClasspathEntries();
                        if (classpathEntries != null && classpathEntries.length > 0) {
                            getCompileImportsRecusively(classpathEntries, jProject, imports, false);
                        }
                    }
                } catch (CoreException e) {
                    _log.error(e.getMessage());
                    continue;
                }
                break;
            }
            case IClasspathEntry.CPE_LIBRARY: {
                // imported jars
                jarPath = PackageUtils.getAbsoluteEntryPath(entry);
                // the jar path can be null if the jar file does not exist
                if (jarPath == null) {
                    throw new CoreException(StatusFactory.createErrorStatus(
                            NLS.bind(Messages.PackagingManager_Entry_Not_Found_MSG, entry.getPath())));
                }
                if (jarPath.lastSegment().equals(IConstants.RIM_API_JAR) && needAddBBJar) {
                    needAddBBJar = false;
                }

                importedJar = null;
                if (PackagingUtils.getPackagExportedJar()) {
                    if (entry.isExported()) {
                        if (isMainProject) {
                            // if the exported jar is not in the main project but a dependent project, the classes it
                            // contains are packaged into the dependent project jar. We don't add it to classpath.
                            importedJar = new ImportedJar(jarPath.toOSString(), true,
                                    getJarFileType(jarPath.toFile()));
                        }
                    } else {
                        importedJar = new ImportedJar(jarPath.toOSString(), false,
                                getJarFileType(jarPath.toFile()));
                    }
                } else {
                    importedJar = new ImportedJar(jarPath.toOSString(), false,
                            getJarFileType(jarPath.toFile()));
                }
                if (importedJar != null && !existingJar(imports, importedJar)) {
                    imports.add(importedJar);
                }
                break;
            }
            case IClasspathEntry.CPE_PROJECT: {
                // dependency projects
                IProject project = workspaceRoot.getProject(entry.getPath().toString());
                IJavaProject javaProject = JavaCore.create(project);
                try {
                    if (project.hasNature(BlackBerryProjectCoreNature.NATURE_ID)) {
                        properties = ContextManager.PLUGIN.getBBProperties(javaProject.getProject().getName(),
                                false);
                        if (properties == null) {
                            _log.error("BlackBerry properties is null");
                            break;
                        }
                    } else {
                        properties = BlackBerryPropertiesFactory.createBlackBerryProperties(javaProject);
                    }
                } catch (CoreException e) {
                    _log.error(e.getMessage());
                    continue;
                }
                if (PackagingManager.getProjectTypeID(properties._application.getType()) == Project.LIBRARY) {
                    IPath absoluteJarPath = PackagingUtils
                            .getAbsoluteStandardOutputFilePath(new BlackBerryProject(javaProject, properties));
                    File jarFile = new File(
                            absoluteJarPath.toOSString() + IConstants.DOT_MARK + IConstants.JAR_EXTENSION);
                    importedJar = new ImportedJar(jarFile.getAbsolutePath(), false, getJarFileType(jarFile));
                    if (!existingJar(imports, importedJar)) {
                        imports.add(importedJar);
                    }
                    IClasspathEntry[] subEntries = javaProject.getRawClasspath();
                    if (subEntries != null && subEntries.length > 0) {
                        getCompileImportsRecusively(subEntries, javaProject, imports, false);
                    }
                }
                break;
            }
            case IClasspathEntry.CPE_VARIABLE: {
                // variables
                String e = entry.getPath().toString();
                int index = e.indexOf('/');
                if (index == -1) {
                    index = e.indexOf('\\');
                }
                String variable = e;
                IPath cpvar = JavaCore.getClasspathVariable(variable);
                if (cpvar == null) {
                    String msg = NLS.bind(Messages.PackagingManager_Variable_Not_Defined_MSG, variable);
                    throw new CoreException(StatusFactory.createErrorStatus(msg));
                }
                if (cpvar.lastSegment().equals(IConstants.RIM_API_JAR) && needAddBBJar) {
                    needAddBBJar = false;
                }
                // TODO RAPC does not support a class folder. We may support it later on
                if (cpvar.lastSegment().endsWith("." + IConstants.JAR_EXTENSION)) {
                    importedJar = new ImportedJar(cpvar.toOSString(), false, getJarFileType(cpvar.toFile()));
                    if (!existingJar(imports, importedJar)) {
                        imports.add(importedJar);
                    }
                }
                break;
            }
            }
        }
        if (needAddBBJar && isMainProject) {
            // insert the default BB jre lib if needed
            IVMInstall bbVM = VMUtils.getDefaultBBVM();
            if (bbVM != null) {
                LibraryLocation[] libLocations = bbVM.getLibraryLocations();
                if (libLocations != null) {
                    for (LibraryLocation location : libLocations) {
                        importedJar = new ImportedJar(location.getSystemLibraryPath().toOSString(), false,
                                getJarFileType(location.getSystemLibraryPath().toFile()));
                        if (!existingJar(imports, importedJar)) {
                            imports.add(importedJar);
                        }
                    }
                }
            }
        }
    } catch (JavaModelException e) {
        _log.error(e.getMessage());
    }
}

---

From source file:net.rim.ejde.internal.sourcelookup.RIMSourcePathProvider.java

License:Open Source License

/**
 * Computes and returns the default unresolved runtime classpath for the given project.
 *
 * @return runtime classpath entries// w  w w  .j  a  v a2s . c  o  m
 * @exception CoreException
 *                if unable to compute the runtime classpath
 * @see IRuntimeClasspathEntry
 */
public static IRuntimeClasspathEntry[] computeUnresolvedRuntimeClasspath(IJavaProject project)
        throws CoreException {
    IClasspathEntry[] entries = project.getRawClasspath();
    List<IRuntimeClasspathEntry> classpathEntries = new ArrayList<IRuntimeClasspathEntry>();
    for (int i = 0; i < entries.length; i++) {
        IClasspathEntry entry = entries[i];
        switch (entry.getEntryKind()) {
        case IClasspathEntry.CPE_CONTAINER:
            IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), project);
            if (container != null) {
                switch (container.getKind()) {
                case IClasspathContainer.K_APPLICATION:
                    // don't look at application entries
                    break;
                case IClasspathContainer.K_DEFAULT_SYSTEM:
                    classpathEntries.add(JavaRuntime.newRuntimeContainerClasspathEntry(container.getPath(),
                            IRuntimeClasspathEntry.STANDARD_CLASSES, project));
                    break;
                case IClasspathContainer.K_SYSTEM:
                    classpathEntries.add(JavaRuntime.newRuntimeContainerClasspathEntry(container.getPath(),
                            IRuntimeClasspathEntry.BOOTSTRAP_CLASSES, project));
                    break;
                }
            }
            break;
        case IClasspathEntry.CPE_VARIABLE:
            if (JavaRuntime.JRELIB_VARIABLE.equals(entry.getPath().segment(0))) {
                IRuntimeClasspathEntry jre = JavaRuntime.newVariableRuntimeClasspathEntry(entry.getPath());
                jre.setClasspathProperty(IRuntimeClasspathEntry.STANDARD_CLASSES);
                classpathEntries.add(jre);
            }
            break;
        default:
            break;
        }
    }
    classpathEntries.add(JavaRuntime.newDefaultProjectClasspathEntry(project));
    return classpathEntries.toArray(new IRuntimeClasspathEntry[classpathEntries.size()]);
}

---

From source file:net.sf.eclipse.tomcat.TomcatBootstrap.java

License:Open Source License

private void getClassPathEntries(IClasspathEntry[] entries, IJavaProject prj, ArrayList data,
        List selectedPaths, ArrayList visitedProjects, IPath outputPath) {
    for (IClasspathEntry entrie : entries) {
        IClasspathEntry entry = entrie;/*from ww  w . j a v  a  2  s . com*/
        IPath path = entry.getPath();
        if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
            path = entry.getOutputLocation();
            if (path == null) {
                continue;
            }
        }
        if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) {
            String prjName = entry.getPath().lastSegment();
            if (!visitedProjects.contains(prjName)) {
                visitedProjects.add(prjName);
                getClassPathEntries(prj.getJavaModel().getJavaProject(prjName), data, selectedPaths,
                        visitedProjects);
            }
            continue;
        } else if (!selectedPaths.contains(path.toFile().toString().replace('\\', '/'))) {
            if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER
                    && !entry.getPath().toString().equals("org.eclipse.jdt.launching.JRE_CONTAINER")) {

                // entires in container are only processed individually
                // if container itself is not selected

                IClasspathContainer container;
                try {
                    container = JavaCore.getClasspathContainer(path, prj);
                } catch (JavaModelException e1) {
                    TomcatLauncherPlugin.log(e1);
                    container = null;
                }

                if (container != null) {
                    getClassPathEntries(container.getClasspathEntries(), prj, data, selectedPaths,
                            visitedProjects, outputPath);
                }
            }
            continue;
        }

        IClasspathEntry[] tmpEntry = null;
        if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
            try {
                tmpEntry = JavaCore.getClasspathContainer(path, prj).getClasspathEntries();
            } catch (JavaModelException e1) {
                TomcatLauncherPlugin.log(e1);
                continue;
            }
        } else {
            tmpEntry = new IClasspathEntry[1];
            tmpEntry[0] = JavaCore.getResolvedClasspathEntry(entry);
        }

        for (IClasspathEntry element : tmpEntry) {
            if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
                IResource res = prj.getProject().getWorkspace().getRoot().findMember(element.getPath());
                if (res != null) {
                    add(data, res);
                } else {
                    add(data, element.getPath());
                }
            } else if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
                IPath srcPath = entry.getOutputLocation();
                if (srcPath != null && !srcPath.equals(outputPath)) {
                    add(data, prj.getProject().getWorkspace().getRoot().findMember(srcPath));
                }
            } else {
                TomcatLauncherPlugin.log(">>> " + element);
                if (element.getPath() != null) {
                    add(data, element.getPath());
                }
            }
        }
    }
}

---

From source file:net.sf.eclipse.tomcat.TomcatBootstrap.java

License:Open Source License

private void collectMavenDependencies(IClasspathEntry[] entries, IJavaProject prj, List data,
        List visitedProjects) {//from w ww  .  j a  v a2  s  . co  m
    for (int i = 0; i < entries.length; i++) {
        IClasspathEntry entry = entries[i];
        IPath path = entry.getPath();
        if ((entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER)
                && entry.getPath().toString().endsWith("MAVEN2_CLASSPATH_CONTAINER")) {
            IClasspathEntry[] tmpEntry = null;
            try {
                tmpEntry = JavaCore.getClasspathContainer(path, prj).getClasspathEntries();
            } catch (JavaModelException e1) {
                TomcatLauncherPlugin.log(e1);
                continue;
            }
            for (int j = 0; j < tmpEntry.length; j++) {
                if (tmpEntry[j].getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
                    if (tmpEntry[j].getPath().lastSegment().matches(".*servlet-api[^\\/]{0,10}\\.jar$")) {
                        continue;
                    }
                    if (tmpEntry[j].getPath().lastSegment().matches(".*jasper[^\\/]{0,10}\\.jar$")) {
                        continue;
                    }
                    if (tmpEntry[j].getPath().lastSegment().matches(".*annotations-api[^\\/]{0,10}.\\.jar$")) {
                        continue;
                    }
                    if (tmpEntry[j].getPath().lastSegment().matches(".*el-api[^\\/]{0,10}\\.jar$")) {
                        continue;
                    }
                    if (tmpEntry[j].getPath().lastSegment().matches(".*jsp-api[^\\/]{0,10}\\.jar$")) {
                        continue;
                    }
                    IResource res = prj.getProject().getWorkspace().getRoot().findMember(tmpEntry[j].getPath());
                    if (res != null) {
                        add(data, res);
                    } else {
                        add(data, tmpEntry[j].getPath());
                    }
                } else if (tmpEntry[j].getEntryKind() == IClasspathEntry.CPE_PROJECT) {
                    String prjName = tmpEntry[j].getPath().lastSegment();
                    IJavaProject subPrj = prj.getJavaModel().getJavaProject(prjName);

                    try {
                        add(data, prj.getProject().getWorkspace().getRoot()
                                .findMember(subPrj.getOutputLocation()));
                    } catch (JavaModelException e1) {
                        TomcatLauncherPlugin.log(e1);
                        continue;
                    }
                    if (!visitedProjects.contains(prjName)) {
                        visitedProjects.add(prjName);
                        collectMavenDependencies(subPrj, data, visitedProjects);
                    }
                    continue;
                } else {
                    TomcatLauncherPlugin.log(">>> " + tmpEntry[j]);
                    if (tmpEntry[j].getPath() != null) {
                        add(data, tmpEntry[j].getPath());
                    }
                }
            }
        }
    }
}

---

From source file:net.sf.eclipse.tomcat.TomcatProjectWebclasspathPropertyPage.java

License:Open Source License

private void getClassPathEntries(IClasspathEntry[] entries, IJavaProject prj, ArrayList data,
        IPath outputPath) {/*  w w  w  .j  av  a  2 s.  c  o m*/
    for (int i = 0; i < entries.length; i++) {
        IClasspathEntry entry = entries[i];
        if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) {
            String prjName = entry.getPath().lastSegment();
            if (!visitedProjects.contains(prjName)) {
                visitedProjects.add(prjName);
                getClassPathEntries(getJavaProject().getJavaModel().getJavaProject(prjName), data);
            }
        } else if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
            add(data, entry.getPath());
        } else if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
            IPath path = entry.getOutputLocation();
            if (path != null && !path.equals(outputPath)) {
                add(data, path);
            }
        } else if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
            if (!entry.getPath().toString().equals("org.eclipse.jdt.launching.JRE_CONTAINER")) {
                // Add container itself, as TomcatBootstrap can actually process them
                // at the moment
                // Basically, users will be able to choose b/w the whole container
                // or some artifacts enclosed by it
                add(data, entry.getPath());

                // Expand container and add its content as individual
                // elements
                IClasspathContainer container;
                try {
                    container = JavaCore.getClasspathContainer(entry.getPath(), prj);
                } catch (JavaModelException e) {
                    TomcatLauncherPlugin.log("failed to obtain classpath container '" + entry.getPath() + "'"
                            + " for project '" + prj.getProject().getName() + "'");
                    TomcatLauncherPlugin.log(e);
                    container = null;
                }

                if (container != null) {
                    getClassPathEntries(container.getClasspathEntries(), prj, data, outputPath);
                }
            }
        } else {
            add(data, entry.getPath());
        }
    }
}

---

From source file:net.sf.fjep.fatjar.popup.actions.BuildFatJar.java

License:Open Source License

private void getChildProjects(IJavaProject jproject, Vector projects, boolean exportedOnly) {

    IClasspathEntry[] cpes = jproject.readRawClasspath();
    if (cpes != null) {
        for (int i = 0; i < cpes.length; i++) {
            IClasspathEntry cpe = JavaCore.getResolvedClasspathEntry(cpes[i]);
            if (cpe == null) {
                System.err.println("Error: cpes[" + i + "]=" + cpes[i] + " does not resolve");
                continue;
            }/*from  w w  w .j ava  2  s . c o  m*/
            int kind = cpe.getEntryKind();
            String name = relPath(cpe.getPath());
            if (kind == IClasspathEntry.CPE_CONTAINER) {
                try {
                    IClasspathContainer container = JavaCore.getClasspathContainer(cpe.getPath(), jproject);
                    if ((container.getKind() == IClasspathContainer.K_APPLICATION)
                            || (container.getKind() == IClasspathContainer.K_SYSTEM)) {
                        IClasspathEntry[] cpes2 = container.getClasspathEntries();
                        for (int j = 0; j < cpes2.length; j++) {
                            IClasspathEntry cpe2 = cpes2[j];
                            int kind2 = cpe2.getEntryKind();
                            String name2 = relPath(cpe2.getPath());
                            if (name2 == null) {
                                System.err.println("invalid classpath entry: " + cpe2.toString());
                            } else {
                                if (kind2 == IClasspathEntry.CPE_PROJECT) {
                                    if (!exportedOnly || cpe2.isExported()) {
                                        if (!projects.contains(name2)) {
                                            IJavaProject jChildProject2 = jproject.getJavaModel()
                                                    .getJavaProject(name2);
                                            projects.add(jChildProject2);
                                            getChildProjects(jChildProject2, projects, true);
                                        }
                                    }
                                }
                            }
                        }
                    }
                } catch (JavaModelException e) {
                }
            } else if (kind == IClasspathEntry.CPE_PROJECT) {
                if (name == null) {
                    System.err.println("invalid classpath entry: " + cpe.toString());
                } else {
                    if (!exportedOnly || cpe.isExported()) {
                        if (!projects.contains(name)) {
                            IJavaProject jChildProject = jproject.getJavaModel().getJavaProject(name);
                            projects.add(jChildProject);
                            getChildProjects(jChildProject, projects, true);
                        }
                    }
                }
            }
        }
    }
}

---

From source file:net.sf.fjep.fatjar.popup.actions.BuildFatJar.java

License:Open Source License

/**
 * Add all jars and class-folders referenced by jproject to jarfiles /
 * classesDirs. If exportedOnly is true, then only jars/class-folders which
 * are marked as exported will be added.
 * /*from   w ww . j av a  2  s.c  o  m*/
 * JRE_LIB (.../jre/lib/rt.jar) is ignored and not added to jarfiles
 * 
 * @param jproject
 * @param jarfiles
 * @param classesDirs
 * @param exportedOnly
 */
private void getClassPathJars(IJavaProject jproject, Vector jarfiles, Vector classesDirs,
        boolean exportedOnly) {

    IProject project = jproject.getProject();
    IWorkspace workspace = project.getWorkspace();
    IWorkspaceRoot workspaceRoot = workspace.getRoot();
    String rootDir = absPath(workspaceRoot.getLocation());
    IClasspathEntry[] cpes = jproject.readRawClasspath();
    // cpes = jproject.getResolvedClasspath(true);
    if (cpes != null) {
        for (int i = 0; i < cpes.length; i++) {
            IClasspathEntry cpe = JavaCore.getResolvedClasspathEntry(cpes[i]);
            if ((cpe != null) && (!exportedOnly || cpe.isExported())) {
                int kind = cpe.getEntryKind();
                String dir = relPath(cpe.getPath());
                if (kind == IClasspathEntry.CPE_CONTAINER) {
                    try {
                        IClasspathContainer container = JavaCore.getClasspathContainer(cpe.getPath(), jproject);
                        if ((container.getKind() == IClasspathContainer.K_APPLICATION)
                                || (container.getKind() == IClasspathContainer.K_SYSTEM)) {
                            IClasspathEntry[] cpes2 = container.getClasspathEntries();
                            for (int j = 0; j < cpes2.length; j++) {
                                IClasspathEntry cpe2 = cpes2[j];
                                int kind2 = cpe2.getEntryKind();
                                String dir2 = relPath(cpe2.getPath());
                                String jar2 = absOrProjectPath(workspaceRoot, dir2);
                                if (jar2 == null) {
                                    System.err.println("invalid classpath entry: " + cpe2.toString());
                                } else {
                                    File f2 = new File(jar2);
                                    if (f2.isDirectory()) {
                                        if (!classesDirs.contains(jar2)) {
                                            classesDirs.add(jar2);
                                        }
                                    } else { // assume jar file
                                        if (!jarfiles.contains(jar2)) {
                                            jarfiles.add(jar2);
                                        }
                                    }
                                }
                            }
                        }
                    } catch (JavaModelException e) {
                    }
                } else if (kind == IClasspathEntry.CPE_LIBRARY) {
                    String jar = absOrProjectPath(workspaceRoot, dir);
                    if (jar == null) {
                        System.err.println("invalid classpath entry: " + cpe.toString());
                    } else {

                        // ignore JRE_LIB
                        if (!jar.replace(File.separatorChar, '/').toLowerCase().endsWith("/jre/lib/rt.jar")) {
                            File f = new File(jar);
                            if (f.isDirectory()) {
                                if (!classesDirs.contains(jar)) {
                                    classesDirs.add(jar);
                                }
                            } else { // assume jar file
                                if (!jarfiles.contains(jar)) {
                                    jarfiles.add(jar);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

---

From source file:net.sf.fjep.fatjar.wizards.export.JProjectConfiguration.java

License:Open Source License

/**
 * Add all jars and class-folders referenced by jproject to jarfiles /
 * classesDirs. If exportedOnly is true, then only jars/class-folders which
 * are marked as exported will be added.
 * //from w  w w  .  jav a  2s. c o m
 * JRE_LIB (.../jre/lib/rt.jar) is ignored and not added to jarfiles
 * 
 * @param jarfiles
 * @param classesDirs
 * @param exportedOnly
 */
public void addClassPathEntries(Vector jarfiles, Vector classesDirs, Vector projects, boolean exportedOnly) {

    IClasspathEntry[] cpes = getRawClasspathEntries();
    if (cpes != null) {
        for (int i = 0; i < cpes.length; i++) {
            IClasspathEntry cpe = JavaCore.getResolvedClasspathEntry(cpes[i]);
            if ((cpe != null) && (!exportedOnly || cpe.isExported())) {
                int kind = cpe.getEntryKind();
                String dir = relPath(cpe.getPath());
                if (kind == IClasspathEntry.CPE_CONTAINER) {
                    try {
                        IClasspathContainer container = JavaCore.getClasspathContainer(cpe.getPath(), jproject);
                        if ((container.getKind() == IClasspathContainer.K_APPLICATION)
                                || (container.getKind() == IClasspathContainer.K_SYSTEM)) {
                            IClasspathEntry[] cpes2 = container.getClasspathEntries();
                            for (int j = 0; j < cpes2.length; j++) {
                                IClasspathEntry cpe2 = cpes2[j];
                                int kind2 = cpe2.getEntryKind();
                                String dir2 = relPath(cpe2.getPath());
                                String jar2 = getAbsOrProjectPath(dir2);
                                if (jar2 == null) {
                                    System.err.println("invalid classpath entry: " + cpe2.toString());
                                } else {
                                    File f2 = new File(jar2);
                                    if (f2.isDirectory()) {
                                        if (!classesDirs.contains(jar2)) {
                                            classesDirs.add(jar2);
                                        }
                                    } else { // assume jar file
                                        if (!jarfiles.contains(jar2)) {
                                            jarfiles.add(jar2);
                                        }
                                    }
                                }
                            }
                        }
                    } catch (JavaModelException e) {
                    }
                } else if (kind == IClasspathEntry.CPE_LIBRARY) {
                    String jar = getAbsOrProjectPath(dir);
                    if (jar == null) {
                        System.err.println("invalid classpath entry: " + cpe.toString());
                    } else {

                        // ignore JRE_LIB
                        if (!jar.replace(File.separatorChar, '/').toLowerCase().endsWith("/jre/lib/rt.jar")) {
                            File f = new File(jar);
                            if (f.isDirectory()) {
                                if (!classesDirs.contains(jar)) {
                                    classesDirs.add(jar);
                                }
                            } else { // assume jar file
                                if (!jarfiles.contains(jar)) {
                                    jarfiles.add(jar);
                                }
                            }
                        }
                    }
                } else if (kind == IClasspathEntry.CPE_PROJECT) {
                    if (!exportedOnly || cpe.isExported()) {
                        IJavaProject jPro = jproject.getJavaModel().getJavaProject(dir);
                        JProjectConfiguration jProCon = new JProjectConfiguration(jPro, null);
                        if (!projects.contains(jProCon)) {
                            projects.add(jProCon);
                        }
                    }
                }
            }
        }
    }
}

---

• «
• 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
• »