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

Introduction

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

Prototype

int CPE_PROJECT

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

Click Source Link

Document

Entry kind constant describing a classpath entry identifying a required project.

Usage

From source file:com.codenvy.ide.ext.java.server.internal.core.ClasspathEntry.java

License:Open Source License

/**
 * Answers an ID which is used to distinguish entries during package
 * fragment root computations//w w w . j  av a 2 s . c o  m
 */
public String rootID() {

    if (this.rootID == null) {
        switch (this.entryKind) {
        case IClasspathEntry.CPE_LIBRARY:
            this.rootID = "[LIB]" + this.path; //$NON-NLS-1$
            break;
        case IClasspathEntry.CPE_PROJECT:
            this.rootID = "[PRJ]" + this.path; //$NON-NLS-1$
            break;
        case IClasspathEntry.CPE_SOURCE:
            this.rootID = "[SRC]" + this.path; //$NON-NLS-1$
            break;
        case IClasspathEntry.CPE_VARIABLE:
            this.rootID = "[VAR]" + this.path; //$NON-NLS-1$
            break;
        case IClasspathEntry.CPE_CONTAINER:
            this.rootID = "[CON]" + this.path; //$NON-NLS-1$
            break;
        default:
            this.rootID = ""; //$NON-NLS-1$
            break;
        }
    }
    return this.rootID;
}

---

From source file:com.codenvy.ide.ext.java.server.internal.core.DeltaProcessingState.java

License:Open Source License

private HashMap[] getRootInfos(boolean usePreviousSession) {
    HashMap newRoots = new HashMap();
    HashMap newOtherRoots = new HashMap();
    HashMap newSourceAttachments = new HashMap();
    HashMap newProjectDependencies = new HashMap();

    IJavaModel model = manager.getJavaModel();
    IJavaProject[] projects;/*from   ww w  .  jav a  2 s. c  om*/
    try {
        projects = model.getJavaProjects();
    } catch (JavaModelException e) {
        // nothing can be done
        return null;
    }
    for (int i = 0, length = projects.length; i < length; i++) {
        JavaProject project = (JavaProject) projects[i];
        IClasspathEntry[] classpath;
        try {
            //            if (usePreviousSession) {
            //               PerProjectInfo perProjectInfo = project.getPerProjectInfo();
            //               project.resolveClasspath(perProjectInfo, true/*use previous session values*/, false/*don't add classpath change*/);
            //               classpath = perProjectInfo.resolvedClasspath;
            //            } else {
            classpath = project.getResolvedClasspath();
            //            }
        } catch (JavaModelException e) {
            // continue with next project
            continue;
        }
        for (int j = 0, classpathLength = classpath.length; j < classpathLength; j++) {
            IClasspathEntry entry = classpath[j];
            if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) {
                IJavaProject key = model.getJavaProject(entry.getPath().segment(0)); // TODO (jerome) reuse handle
                IJavaProject[] dependents = (IJavaProject[]) newProjectDependencies.get(key);
                if (dependents == null) {
                    dependents = new IJavaProject[] { project };
                } else {
                    int dependentsLength = dependents.length;
                    System.arraycopy(dependents, 0, dependents = new IJavaProject[dependentsLength + 1], 0,
                            dependentsLength);
                    dependents[dependentsLength] = project;
                }
                newProjectDependencies.put(key, dependents);
                continue;
            }

            // root path
            IPath path = entry.getPath();
            if (newRoots.get(path) == null) {
                newRoots.put(path,
                        new DeltaProcessor.RootInfo(project, path,
                                ((ClasspathEntry) entry).fullInclusionPatternChars(),
                                ((ClasspathEntry) entry).fullExclusionPatternChars(), entry.getEntryKind()));
            } else {
                ArrayList rootList = (ArrayList) newOtherRoots.get(path);
                if (rootList == null) {
                    rootList = new ArrayList();
                    newOtherRoots.put(path, rootList);
                }
                rootList.add(new DeltaProcessor.RootInfo(project, path,
                        ((ClasspathEntry) entry).fullInclusionPatternChars(),
                        ((ClasspathEntry) entry).fullExclusionPatternChars(), entry.getEntryKind()));
            }

            // source attachment path
            if (entry.getEntryKind() != IClasspathEntry.CPE_LIBRARY)
                continue;
            String propertyString = null;
            //            try {
            //               propertyString = Util.getSourceAttachmentProperty(path);
            //            } catch (JavaModelException e) {
            //               e.printStackTrace();
            //            }
            IPath sourceAttachmentPath;
            if (propertyString != null) {
                int index = propertyString.lastIndexOf(PackageFragmentRoot.ATTACHMENT_PROPERTY_DELIMITER);
                sourceAttachmentPath = (index < 0) ? new Path(propertyString)
                        : new Path(propertyString.substring(0, index));
            } else {
                sourceAttachmentPath = entry.getSourceAttachmentPath();
            }
            if (sourceAttachmentPath != null) {
                newSourceAttachments.put(sourceAttachmentPath, path);
            }
        }
    }
    return new HashMap[] { newRoots, newOtherRoots, newSourceAttachments, newProjectDependencies };
}

---

From source file:com.codenvy.ide.ext.java.server.internal.core.search.IndexSelector.java

License:Open Source License

private static boolean canSeeFocus(IJavaElement focus, JavaProject javaProject,
        char[][][] focusQualifiedNames) {
    try {/* ww w . ja  v  a2  s  .co  m*/
        if (focus == null)
            return false;
        if (focus.equals(javaProject))
            return true;

        if (focus instanceof JarPackageFragmentRoot) {
            // focus is part of a jar
            IPath focusPath = focus.getPath();
            IClasspathEntry[] entries = javaProject.getExpandedClasspath();
            for (int i = 0, length = entries.length; i < length; i++) {
                IClasspathEntry entry = entries[i];
                if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY && entry.getPath().equals(focusPath))
                    return true;
            }
            return false;
        }
        // look for dependent projects
        IPath focusPath = ((JavaProject) focus).getProject().getFullPath();
        IClasspathEntry[] entries = javaProject.getExpandedClasspath();
        for (int i = 0, length = entries.length; i < length; i++) {
            IClasspathEntry entry = entries[i];
            if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT && entry.getPath().equals(focusPath)) {
                if (focusQualifiedNames != null) { // builder state is usable, hence use it to try to reduce project which can see the focus...
                    State projectState = (State) JavaModelManager.getJavaModelManager()
                            .getLastBuiltState(javaProject.getProject(), null);
                    if (projectState != null) {
                        Object[] values = projectState.getReferences().valueTable;
                        int vLength = values.length;
                        for (int j = 0; j < vLength; j++) {
                            if (values[j] == null)
                                continue;
                            ReferenceCollection references = (ReferenceCollection) values[j];
                            if (references.includes(focusQualifiedNames, null, null)) {
                                return true;
                            }
                        }
                        return false;
                    }
                }
                return true;
            }
        }
        return false;
    } catch (JavaModelException e) {
        return false;
    }
}

---

From source file:com.codenvy.ide.ext.java.server.internal.core.search.JavaSearchScope.java

License:Open Source License

/**
 * Add a path to current java search scope or all project fragment roots if null.
 * Use project resolved classpath to retrieve and store access restriction on each classpath entry.
 * Recurse if dependent projects are found.
 *
 * @param javaProject/* w  ww.  jav a2  s.co  m*/
 *         Project used to get resolved classpath entries
 * @param pathToAdd
 *         Path to add in case of single element or null if user want to add all project package fragment roots
 * @param includeMask
 *         Mask to apply on classpath entries
 * @param projectsToBeAdded
 *         Set to avoid infinite recursion
 * @param visitedProjects
 *         Set to avoid adding twice the same project
 * @param referringEntry
 *         Project raw entry in referring project classpath
 * @throws org.eclipse.jdt.core.JavaModelException
 *         May happen while getting java model info
 */
void add(JavaProject javaProject, IPath pathToAdd, int includeMask, HashSet projectsToBeAdded,
        HashSet visitedProjects, IClasspathEntry referringEntry) throws JavaModelException {
    //        IProject project = javaProject.getProject();
    //        if (!project.isAccessible() || !visitedProjects.add(project)) return;

    IPath projectPath = javaProject.getFullPath();
    String projectPathString = projectPath.toString();
    addEnclosingProjectOrJar(projectPath);

    IClasspathEntry[] entries = javaProject.getResolvedClasspath();
    //        IJavaModel model = javaProject.getJavaModel();
    //        JavaModelManager.PerProjectInfo perProjectInfo = javaProject.getPerProjectInfo();
    for (int i = 0, length = entries.length; i < length; i++) {
        IClasspathEntry entry = entries[i];
        AccessRuleSet access = null;
        ClasspathEntry cpEntry = (ClasspathEntry) entry;
        if (referringEntry != null) {
            // Add only exported entries.
            // Source folder are implicitly exported.
            if (!entry.isExported() && entry.getEntryKind() != IClasspathEntry.CPE_SOURCE) {
                continue;
            }
            cpEntry = cpEntry.combineWith((ClasspathEntry) referringEntry);
            //            cpEntry = ((ClasspathEntry)referringEntry).combineWith(cpEntry);
        }
        access = cpEntry.getAccessRuleSet();
        switch (entry.getEntryKind()) {
        case IClasspathEntry.CPE_LIBRARY:
            IClasspathEntry rawEntry = null;
            //                    Map rootPathToRawEntries = perProjectInfo.rootPathToRawEntries;
            //                    if (rootPathToRawEntries != null) {
            //                        rawEntry = (IClasspathEntry)rootPathToRawEntries.get(entry.getPath());
            //                    }
            //                    if (rawEntry == null) break;
            rawKind: switch (cpEntry.getEntryKind()) {
            case IClasspathEntry.CPE_LIBRARY:
            case IClasspathEntry.CPE_VARIABLE:
                if ((includeMask & APPLICATION_LIBRARIES) != 0) {
                    IPath path = entry.getPath();
                    if (pathToAdd == null || pathToAdd.equals(path)) {
                        //                                    Object target = JavaModel.getTarget(path, false/*don't check existence*/);
                        //                                    if (target instanceof IFolder) // case of an external folder
                        //                                        path = ((IFolder)target).getFullPath();
                        String pathToString = path.getDevice() == null ? path.toString() : path.toOSString();
                        add(projectPath.toString(), "", pathToString, false/*not a package*/, access); //$NON-NLS-1$
                        addEnclosingProjectOrJar(entry.getPath());
                    }
                }
                break;
            case IClasspathEntry.CPE_CONTAINER:
                IClasspathContainer container = JavaCore.getClasspathContainer(rawEntry.getPath(), javaProject);
                if (container == null)
                    break;
                switch (container.getKind()) {
                case IClasspathContainer.K_APPLICATION:
                    if ((includeMask & APPLICATION_LIBRARIES) == 0)
                        break rawKind;
                    break;
                case IClasspathContainer.K_SYSTEM:
                case IClasspathContainer.K_DEFAULT_SYSTEM:
                    if ((includeMask & SYSTEM_LIBRARIES) == 0)
                        break rawKind;
                    break;
                default:
                    break rawKind;
                }
                IPath path = entry.getPath();
                if (pathToAdd == null || pathToAdd.equals(path)) {
                    Object target = JavaModel.getTarget(path, false/*don't check existence*/);
                    if (target instanceof IFolder) // case of an external folder
                        path = ((IFolder) target).getFullPath();
                    String pathToString = path.getDevice() == null ? path.toString() : path.toOSString();
                    add(projectPath.toString(), "", pathToString, false/*not a package*/, access); //$NON-NLS-1$
                    addEnclosingProjectOrJar(entry.getPath());
                }
                break;
            }
            break;
        case IClasspathEntry.CPE_PROJECT:
            //                    if ((includeMask & REFERENCED_PROJECTS) != 0) {
            //                        IPath path = entry.getPath();
            //                        if (pathToAdd == null || pathToAdd.equals(path)) {
            //                            JavaProject referencedProject = (JavaProject)model.getJavaProject(path.lastSegment());
            //                            if (!projectsToBeAdded
            //                                    .contains(referencedProject)) { // do not recurse if depending project was used to create the scope
            //                                add(referencedProject, null, includeMask, projectsToBeAdded, visitedProjects, cpEntry);
            //                            }
            //                        }
            //                    }
            break;
        case IClasspathEntry.CPE_SOURCE:
            if ((includeMask & SOURCES) != 0) {
                IPath path = entry.getPath();
                if (pathToAdd == null || pathToAdd.equals(path)) {
                    add(projectPath.toString(), Util.relativePath(path, 1/*remove project segment*/),
                            projectPathString, false/*not a package*/, access);
                }
            }
            break;
        }
    }
}

---

From source file:com.ebmwebsourcing.petals.common.internal.provisional.utils.JavaUtils.java

License:Open Source License

/**
 * Get the class path from Java project.
 *
 * @param javaProject//from   ww  w  .  jav a2  s. c om
 * @param getReferencedProjectClasspath
 * @param binaryDirectory
 * @return the class path as a list of string locations.
 */
public static List<String> getClasspath(IJavaProject javaProject, boolean getReferencedProjectClasspath,
        boolean binaryDirectory) {

    List<String> paths = new ArrayList<String>();
    try {
        if (javaProject != null) {

            // Get the raw class path
            IClasspathEntry[] entries = javaProject.getRawClasspath();
            for (IClasspathEntry entry : entries) {
                switch (entry.getEntryKind()) {

                case IClasspathEntry.CPE_PROJECT:
                    if (!getReferencedProjectClasspath)
                        break;

                    String projectName = entry.getPath().toString();
                    IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
                    IJavaProject jProject = JavaCore.create(project);

                    List<String> subPaths = getClasspath(jProject, true, binaryDirectory);
                    paths.addAll(subPaths);
                    break;

                case IClasspathEntry.CPE_LIBRARY:
                    IPath path = entry.getPath();
                    paths.add(path.toString());
                    break;

                case IClasspathEntry.CPE_VARIABLE:
                    entry = JavaCore.getResolvedClasspathEntry(entry);
                    if (entry != null) {
                        path = entry.getPath();
                        paths.add(path.toString());
                    }
                    break;

                }
            }

            // Add the "bin" directory?
            if (binaryDirectory && javaProject.getOutputLocation() != null) {
                IPath path = ResourcesPlugin.getWorkspace().getRoot().getLocation();
                path = path.append(javaProject.getOutputLocation());
                paths.add(path.toString());
            }
        }

    } catch (JavaModelException e) {
        PetalsCommonPlugin.log(e, IStatus.ERROR);
    }

    return paths;
}

---

From source file:com.ebmwebsourcing.petals.common.internal.provisional.utils.JavaUtils.java

License:Open Source License

/**
 * Populates an {@link ExportableClassPath} instance from a class path entry.
 * @param result the {@link ExportableClassPath} instance to populate
 * @param entry a class path entry//from   w ww  .j a va  2  s  .com
 * @param monitor the progress monitor
 */
private static void updateExportableResult(ExportableClassPath result, IClasspathEntry entry,
        IProgressMonitor monitor) {

    switch (entry.getEntryKind()) {

    case IClasspathEntry.CPE_PROJECT:
        String projectName = entry.getPath().toString();
        IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
        IJavaProject jProject = JavaCore.create(project);

        ExportableClassPath subResult = getExportableClasspath(jProject, monitor);
        result.implementationJars.addAll(subResult.implementationJars);
        result.libraryJars.addAll(subResult.libraryJars);
        monitor.worked(1);
        break;

    case IClasspathEntry.CPE_LIBRARY:
        IPath path = entry.getPath();
        if (path != null) {
            File f = path.toFile();
            if (f.exists()) {
                if (f.getName().endsWith(".zip") || f.getName().endsWith(".jar"))
                    result.libraryJars.add(f);
            }
        }
        break;

    case IClasspathEntry.CPE_VARIABLE:
        entry = JavaCore.getResolvedClasspathEntry(entry);
        if (entry != null)
            updateExportableResult(result, entry, monitor);

        break;
    }
}

---

From source file:com.google.gwt.eclipse.core.runtime.RuntimeClasspathEntryResolver.java

License:Open Source License

/**
 * Given a list of IClasspathEntry, produce an array of IRuntimeClasspathEntry based on that list.
 *//*from  w w w .  j a va2s . c  o m*/
private IRuntimeClasspathEntry[] resolveClasspathEntries(List<IClasspathEntry> classpathEntries)
        throws CoreException {
    LinkedHashSet<IRuntimeClasspathEntry> runtimeClasspathEntries = new LinkedHashSet<IRuntimeClasspathEntry>();

    for (IClasspathEntry classpathEntry : classpathEntries) {
        if (classpathEntry.getEntryKind() == IClasspathEntry.CPE_PROJECT) {
            String projectName = classpathEntry.getPath().lastSegment();
            IJavaProject theproject = JavaProjectUtilities.findJavaProject(projectName);

            IRuntimeClasspathEntry projectEntry = JavaRuntime.newProjectRuntimeClasspathEntry(theproject);
            runtimeClasspathEntries.add(projectEntry);
            runtimeClasspathEntries.addAll(dependenciesForProject(theproject));
        } else {
            runtimeClasspathEntries.add(JavaRuntime.newArchiveRuntimeClasspathEntry(classpathEntry.getPath()));
        }
    }

    return runtimeClasspathEntries.toArray(NO_ENTRIES);
}

---

From source file:com.google.gwt.eclipse.core.runtime.tools.WebAppProjectCreatorRunner.java

License:Open Source License

private static String computeClasspath(GWTRuntime gwtRuntime, String[] extraClassPath) throws CoreException {
    List<String> cpPaths = new ArrayList<String>();
    for (IClasspathEntry c : gwtRuntime.getClasspathEntries()) {
        if (c.getEntryKind() == IClasspathEntry.CPE_PROJECT) {
            IJavaProject javaProject = JavaProjectUtilities.findJavaProject(c.getPath().toOSString());
            IRuntimeClasspathEntry projectRuntimeEntry = JavaRuntime
                    .newDefaultProjectClasspathEntry(javaProject);
            IRuntimeClasspathEntry[] resolvedEntries = JavaRuntime
                    .resolveRuntimeClasspathEntry(projectRuntimeEntry, javaProject);
            for (IRuntimeClasspathEntry resolvedEntry : resolvedEntries) {
                cpPaths.add(resolvedEntry.getLocation());
            }// w w  w  . j a  va  2  s .  c  om
        } else {
            cpPaths.add(c.getPath().toFile().getAbsolutePath());
        }
    }
    if (extraClassPath != null) {
        cpPaths.addAll(Arrays.asList(extraClassPath));
    }
    return ProcessUtilities.buildClasspathString(cpPaths);
}

---

From source file:com.google.inject.tools.ideplugin.eclipse.EclipseJavaProject.java

License:Apache License

private List<String> expandClasspath(IClasspathEntry[] entries, String projectName, String projectLocation)
        throws Exception {
    final List<String> args = new ArrayList<String>();
    IResource presource;/*from  w  w  w .  ja v  a  2  s  .  c  o m*/
    String resourceLocation;
    String path;
    for (IClasspathEntry entry : entries) {
        switch (entry.getEntryKind()) {
        case IClasspathEntry.CPE_CONTAINER:
            IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), project);
            args.addAll(expandClasspath(container.getClasspathEntries(), projectName, projectLocation));
            break;
        case IClasspathEntry.CPE_SOURCE:
            IResource resource = ResourcesPlugin.getWorkspace().getRoot().findMember(entry.getPath());
            path = resource.getLocation().makeAbsolute().toOSString();
            if (path.startsWith("/" + projectName)) {
                args.add(path.replaceFirst("/" + projectName, projectLocation));
            } else {
                args.add(path);
            }
            break;
        case IClasspathEntry.CPE_LIBRARY:
            path = entry.getPath().makeAbsolute().toOSString();
            if (path.startsWith("/" + projectName)) {
                args.add(path.replaceFirst("/" + projectName, projectLocation));
            } else {
                args.add(path);
            }
            break;
        case IClasspathEntry.CPE_PROJECT:
            presource = ResourcesPlugin.getWorkspace().getRoot().findMember(entry.getPath());
            resourceLocation = presource.getLocation().makeAbsolute().toOSString();
            String outputLocation = resourceLocation;
            args.add(outputLocation.replaceFirst(presource.getName(), resourceLocation));
            break;
        case IClasspathEntry.CPE_VARIABLE:
            break;
        default:
            //never happens
        }
    }
    return args;
}

---

From source file:com.ibm.wala.ide.util.JavaEclipseProjectPath.java

License:Open Source License

@Override
protected void resolveClasspathEntry(IJavaProject project, IClasspathEntry entry, ILoader loader,
        boolean includeSource, boolean cpeFromMainProject) {
    entry = JavaCore.getResolvedClasspathEntry(entry);
    switch (entry.getEntryKind()) {
    case IClasspathEntry.CPE_SOURCE: {
        resolveSourcePathEntry(includeSource ? JavaSourceLoader.SOURCE : Loader.APPLICATION, includeSource,
                cpeFromMainProject, entry.getPath(), entry.getOutputLocation(), entry.getExclusionPatterns(),
                "java");
        break;//  w w w .  j  a  va2 s .  co  m
    }
    case IClasspathEntry.CPE_LIBRARY: {
        resolveLibraryPathEntry(loader, entry.getPath());
        break;
    }
    case IClasspathEntry.CPE_PROJECT: {
        resolveProjectPathEntry(loader, includeSource, entry.getPath());
        break;
    }
    case IClasspathEntry.CPE_CONTAINER: {
        try {
            IClasspathContainer cont = JavaCore.getClasspathContainer(entry.getPath(), project);
            IClasspathEntry[] entries = cont.getClasspathEntries();
            resolveClasspathEntries(project, Arrays.asList(entries),
                    cont.getKind() == IClasspathContainer.K_APPLICATION ? loader : Loader.PRIMORDIAL,
                    includeSource, false);
        } catch (CoreException e) {
            System.err.println(e);
            Assertions.UNREACHABLE();
        }
    }
    }
}

---

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