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

List of usage examples for org.eclipse.jdt.core IClasspathEntry CPE_VARIABLE

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.*
  5. IClasspathEntry
  6. CPE_VARIABLE

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.eclipse.jst.j2ee.internal.servertarget.ServerTargetHelper.java

License:Open Source License

public static List getExistingNonServerTargetClasspath(IProject project) {
    IJavaProject javaProject = null;/*from w w  w .  jav  a 2  s .c  om*/
    List list = new ArrayList();
    try {
        javaProject = (IJavaProject) project.getNature(JavaCore.NATURE_ID);
    } catch (Exception e) {
    }
    if (javaProject != null) {
        try {
            IClasspathEntry[] cp = javaProject.getRawClasspath();
            int size = cp.length;
            for (int i = 0; i < size; i++) {
                int entryKind = cp[i].getEntryKind();
                if (entryKind != IClasspathEntry.CPE_SOURCE && entryKind != IClasspathEntry.CPE_LIBRARY
                        && entryKind != IClasspathEntry.CPE_PROJECT
                        && (entryKind == IClasspathEntry.CPE_VARIABLE && isWASVariable(cp[i]))
                        && (entryKind != IClasspathEntry.CPE_CONTAINER
                                || !cp[i].getPath().segment(0).equals(SERVER_CONTAINER))) {
                    list.add(cp[i]);
                }
            }
        } catch (Exception e) {
        }
        return list;
    }
    return list;
}

From source file:org.eclipse.jst.j2ee.internal.ui.AddJavaBuildPathEntriesWizardFragment.java

License:Open Source License

public static Image getClasspathEntryImage(final IJavaProject jproj, final IClasspathEntry cpe) {
    final int type = cpe.getEntryKind();
    final String imgId;

    if (type == IClasspathEntry.CPE_CONTAINER) {
        imgId = ISharedImages.IMG_OBJS_LIBRARY;
    } else if (type == IClasspathEntry.CPE_LIBRARY) {
        imgId = ISharedImages.IMG_OBJS_JAR;
    } else if (type == IClasspathEntry.CPE_VARIABLE) {
        imgId = ISharedImages.IMG_OBJS_CLASSPATH_VAR_ENTRY;
    } else {// w  w  w .ja  va 2 s  .c o m
        imgId = null;
    }

    return (imgId == null ? null : JavaUI.getSharedImages().getImage(imgId));
}

From source file:org.eclipse.jst.jsp.core.taglib.ProjectDescription.java

License:Open Source License

/**
 * @param entry// w  ww .j  a v a2  s . c o  m
 */
private void indexClasspath(IClasspathEntry entry) {
    switch (entry.getEntryKind()) {
    case IClasspathEntry.CPE_CONTAINER: {
        IClasspathContainer container = (IClasspathContainer) entry;
        IClasspathEntry[] containedEntries = container.getClasspathEntries();
        for (int i = 0; i < containedEntries.length; i++) {
            indexClasspath(containedEntries[i]);
        }
    }
        break;
    case IClasspathEntry.CPE_LIBRARY: {
        /*
         * Ignore libs in required projects that are not exported
         */
        IPath libPath = entry.getPath();
        if (!fClasspathJars.containsKey(libPath.toString())) {
            final File file = libPath.toFile();
            if (file.exists()) {
                if (file.isDirectory()) {
                    indexDirectory(file, entry.isExported());
                } else {
                    updateClasspathLibrary(libPath.toString(), ITaglibIndexDelta.ADDED, entry.isExported());
                }
            } else {
                /*
                 * Note: .jars on the classpath inside of the project
                 * will have duplicate entries in the JAR references
                 * table that will e returned to
                 * getAvailableTaglibRecords().
                 */
                IResource resource = ResourcesPlugin.getWorkspace().getRoot().findMember(libPath);
                if (resource != null && resource.isAccessible()) {
                    if (resource.getType() == IResource.FILE) {
                        if (resource.getLocation() != null) {
                            updateClasspathLibrary(resource.getLocation().toString(), ITaglibIndexDelta.ADDED,
                                    entry.isExported());
                        }
                    } else if (resource.getType() == IResource.FOLDER) {
                        try {
                            resource.accept(new Indexer(), 0);
                        } catch (CoreException e) {
                            Logger.logException(e);
                        }
                    }
                }
            }
        }
    }
        break;
    case IClasspathEntry.CPE_PROJECT: {
        /*
         * We're currently ignoring whether the project exports all of
         * its build path
         */
        IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(entry.getPath().lastSegment());
        if (project != null) {
            fClasspathProjects.add(project);
        }
    }
        break;
    case IClasspathEntry.CPE_SOURCE: {
        IPath path = entry.getPath();
        try {
            IResource sourceFolder = ResourcesPlugin.getWorkspace().getRoot().findMember(path);
            // could be a bad .classpath file
            if (sourceFolder != null) {
                sourceFolder.accept(new Indexer(), 0);
            }
        } catch (CoreException e) {
            Logger.logException(e);
        }
    }
        break;
    case IClasspathEntry.CPE_VARIABLE: {
        IPath libPath = JavaCore.getResolvedVariablePath(entry.getPath());
        if (libPath != null) {
            File file = libPath.toFile();

            // file in filesystem
            if (file.exists() && !file.isDirectory()) {
                updateClasspathLibrary(libPath.toString(), ITaglibRecordEvent.ADDED, entry.isExported());
            } else {
                // workspace file
                IFile jarFile = ResourcesPlugin.getWorkspace().getRoot().getFile(libPath);
                if (jarFile.isAccessible() && jarFile.getType() == IResource.FILE
                        && jarFile.getLocation() != null) {
                    String jarPathString = jarFile.getLocation().toString();
                    updateClasspathLibrary(jarPathString, ITaglibRecordEvent.ADDED, entry.isExported());
                }
            }
        }
    }
        break;
    }
}

From source file:org.eclipse.jst.server.tomcat.core.internal.TomcatServerUtil.java

License:Open Source License

/**
 * Returns the kind of a <code>PackageFragmentRoot</code> from its <code>String</code> form.
 *///from w  w w.j a v  a  2s . com
protected static int getClasspathKindFromString(String kindStr) {
    //if (kindStr.equalsIgnoreCase("prj"))
    //   return IClasspathEntry.CPE_PROJECT;
    if (kindStr.equalsIgnoreCase("var"))
        return IClasspathEntry.CPE_VARIABLE;
    //if (kindStr.equalsIgnoreCase("src"))
    //   return IClasspathEntry.CPE_SOURCE;
    if (kindStr.equalsIgnoreCase("lib"))
        return IClasspathEntry.CPE_LIBRARY;
    return -1;
}

From source file:org.eclipse.jst.server.tomcat.core.internal.TomcatServerUtil.java

License:Open Source License

/**
 * Returns a <code>String</code> for the kind of a class path entry.
 *//* www  . j a  v a 2  s.  co  m*/
protected static String getClasspathKindToString(int kind) {
    switch (kind) {
    //case IClasspathEntry.CPE_PROJECT :
    //   return "prj";
    //case IClasspathEntry.CPE_SOURCE :
    //   return "src";
    case IClasspathEntry.CPE_LIBRARY:
        return "lib";
    case IClasspathEntry.CPE_VARIABLE:
        return "var";
    default:
        return "unknown";
    }
}

From source file:org.eclipse.jst.server.tomcat.core.internal.TomcatServerUtil.java

License:Open Source License

/**
 * Create's a classpath entry of the specified kind.
 *
 * Returns null if unable to create a valid entry.
 *//*from  ww  w .j a  v a 2  s .c o m*/
protected static IClasspathEntry createClasspathEntry(IPath path, int kind, IPath sourceAttachmentPath,
        IPath sourceAttachmentRootPath) {
    switch (kind) {
    /*case IClasspathEntry.CPE_PROJECT:
    if (!path.isAbsolute())
       return null;
    else
       return JavaCore.newProjectEntry(path);*/

    case IClasspathEntry.CPE_LIBRARY:
        if (!path.isAbsolute())
            return null;

        return JavaCore.newLibraryEntry(path, sourceAttachmentPath, sourceAttachmentRootPath);

    case IClasspathEntry.CPE_VARIABLE:
        return JavaCore.newVariableEntry(path, sourceAttachmentPath, sourceAttachmentRootPath);

    default:
        return null;
    }
}

From source file:org.eclipse.jst.ws.internal.axis.consumption.ui.util.ClasspathUtils.java

License:Open Source License

private String[] classpathEntry2String(IClasspathEntry entry, IProject project) {
    switch (entry.getEntryKind()) {
    case IClasspathEntry.CPE_LIBRARY: {
        return new String[] { path2String(entry.getPath()) };
    }// ww  w  . ja v  a2 s. c  o m
    case IClasspathEntry.CPE_PROJECT: {
        return getClasspath(ResourcesPlugin.getWorkspace().getRoot().getProject(entry.getPath().lastSegment()),
                true);
    }
    case IClasspathEntry.CPE_SOURCE: {
        IPath path = entry.getPath();
        if (path.segment(0).equals(project.getName()))
            path = path.removeFirstSegments(1);
        return new String[] { path2String(project.getLocation().addTrailingSeparator().append(path)) };
    }
    case IClasspathEntry.CPE_VARIABLE: {
        return classpathEntry2String(JavaCore.getResolvedClasspathEntry(entry), project);
    }
    default: {
        return new String[] { path2String(entry.getPath()) };
    }
    }
}

From source file:org.eclipse.m2e.jdt.internal.BuildPathManager.java

License:Open Source License

public boolean variablesAreInUse() {
    try {//from w w  w  . j av a2s.  c o  m
        IJavaModel model = JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());
        IJavaProject[] projects = model.getJavaProjects();
        for (int i = 0; i < projects.length; i++) {
            IClasspathEntry[] entries = projects[i].getRawClasspath();
            for (int k = 0; k < entries.length; k++) {
                IClasspathEntry curr = entries[k];
                if (curr.getEntryKind() == IClasspathEntry.CPE_VARIABLE) {
                    String var = curr.getPath().segment(0);
                    if (M2_REPO.equals(var)) {
                        return true;
                    }
                }
            }
        }
    } catch (JavaModelException e) {
        return true;
    }
    return false;
}

From source file:org.eclipse.m2e.jdt.internal.launch.MavenRuntimeClasspathProvider.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;//w w w  .jav  a  2 s .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;
                //                case IClasspathContainer.K_DEFAULT_SYSTEM:
                //                  unresolved.add(JavaRuntime.newRuntimeContainerClasspathEntry(container.getPath(), IRuntimeClasspathEntry.STANDARD_CLASSES, javaProject));
                //                  break;
                //                case IClasspathContainer.K_SYSTEM:
                //                  unresolved.add(JavaRuntime.newRuntimeContainerClasspathEntry(container.getPath(), IRuntimeClasspathEntry.BOOTSTRAP_CLASSES, javaProject));
                //                  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:org.eclipse.pde.api.tools.internal.model.ProjectComponent.java

License:Open Source License

@Override
protected synchronized List<IApiTypeContainer> createApiTypeContainers() throws CoreException {
    // first populate build.properties cache so we can create class file
    // containers
    // from bundle classpath entries
    fPathToOutputContainers = new HashMap<String, IApiTypeContainer>(4);
    fOutputLocationToContainer = new HashMap<IPath, IApiTypeContainer>(4);
    if (fProject.exists() && fProject.getProject().isOpen()) {
        IPluginModelBase model = PluginRegistry.findModel(fProject.getProject());
        if (model != null) {
            IBuildModel buildModel = PluginRegistry.createBuildModel(model);
            if (buildModel != null) {
                IBuild build = buildModel.getBuild();
                IBuildEntry entry = build.getEntry(ENTRY_CUSTOM);
                if (entry != null) {
                    String[] tokens = entry.getTokens();
                    if (tokens.length == 1 && tokens[0].equals("true")) { //$NON-NLS-1$
                        // hack : add the current output location for each
                        // classpath entries
                        IClasspathEntry[] classpathEntries = fProject.getRawClasspath();
                        List<IApiTypeContainer> containers = new ArrayList<IApiTypeContainer>();
                        for (int i = 0; i < classpathEntries.length; i++) {
                            IClasspathEntry classpathEntry = classpathEntries[i];
                            switch (classpathEntry.getEntryKind()) {
                            case IClasspathEntry.CPE_SOURCE:
                                String containerPath = classpathEntry.getPath().removeFirstSegments(1)
                                        .toString();
                                IApiTypeContainer container = getApiTypeContainer(containerPath, this);
                                if (container != null && !containers.contains(container)) {
                                    containers.add(container);
                                }//from   ww w . j  a  v  a2 s  .com
                                break;
                            case IClasspathEntry.CPE_VARIABLE:
                                classpathEntry = JavaCore.getResolvedClasspathEntry(classpathEntry);
                                //$FALL-THROUGH$
                            case IClasspathEntry.CPE_LIBRARY:
                                IPath path = classpathEntry.getPath();
                                if (Util.isArchive(path.lastSegment())) {
                                    IResource resource = ResourcesPlugin.getWorkspace().getRoot()
                                            .findMember(path);
                                    if (resource != null) {
                                        // jar inside the workspace
                                        containers.add(new ArchiveApiTypeContainer(this,
                                                resource.getLocation().toOSString()));
                                    } else {
                                        // external jar
                                        containers.add(new ArchiveApiTypeContainer(this, path.toOSString()));
                                    }
                                }
                                break;
                            default:
                                break;
                            }
                        }
                        if (!containers.isEmpty()) {
                            IApiTypeContainer cfc = null;
                            if (containers.size() == 1) {
                                cfc = containers.get(0);
                            } else {
                                cfc = new CompositeApiTypeContainer(this, containers);
                            }
                            fPathToOutputContainers.put(".", cfc); //$NON-NLS-1$
                        }
                    }
                } else {
                    IBuildEntry[] entries = build.getBuildEntries();
                    int length = entries.length;
                    for (int i = 0; i < length; i++) {
                        IBuildEntry buildEntry = entries[i];
                        String name = buildEntry.getName();
                        if (name.startsWith(IBuildEntry.JAR_PREFIX)) {
                            retrieveContainers(name, IBuildEntry.JAR_PREFIX, buildEntry);
                        } else if (name.startsWith(EXTRA_PREFIX)) {
                            retrieveContainers(name, EXTRA_PREFIX, buildEntry);
                        }
                    }
                }
            }
        }
        return super.createApiTypeContainers();
    }
    return Collections.EMPTY_LIST;
}