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

Introduction

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

Prototype

int CPE_VARIABLE

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

Click Source Link

Document

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

Usage

From source file:org.antlr.eclipse.core.AntlrNature.java

License:Open Source License

/**
 * Add the ANTLR nature to a project/* w ww.ja  v a 2s.c  o  m*/
 * @param aProject The project to add it to
 * @param aMonitor A progess monitor
 */
public static void addNature(final IProject aProject, final IProgressMonitor aMonitor) {
    if (aProject != null) {
        if (DEBUG) {
            System.out.println("adding ANTLR nature to project '" + aProject.getName() + "'");
        }
        try {
            if (!aProject.hasNature(ID)) {
                IProjectDescription desc = aProject.getDescription();
                ArrayList<String> natures = new ArrayList<String>(Arrays.asList(desc.getNatureIds()));
                natures.add(0, ID);
                desc.setNatureIds(natures.toArray(new String[natures.size()]));
                aProject.setDescription(desc, aMonitor);

                // if it's a Java project, set up classpath variable for:
                //    ANTLR_HOME
                // these will point to the ANTLR plugins' 
                //   jars, respectively
                if (aProject.hasNature(JavaCore.NATURE_ID)) {
                    IJavaProject javaProject = JavaCore.create(aProject);
                    ArrayList<IClasspathEntry> rawClasspath = new ArrayList<IClasspathEntry>(
                            Arrays.asList(javaProject.getRawClasspath()));
                    boolean hasAntlrJar = false;
                    for (Iterator<IClasspathEntry> i = rawClasspath.iterator(); i.hasNext();) {
                        IClasspathEntry entry = i.next();
                        if (entry.getEntryKind() == IClasspathEntry.CPE_VARIABLE) {
                            String segment0 = entry.getPath().segment(0);
                            if (AntlrCorePlugin.ANTLR_HOME.equals(segment0)) {
                                hasAntlrJar = true;
                                break;
                            }
                        }
                    }
                    if (!hasAntlrJar)
                        rawClasspath.add(
                                JavaCore.newVariableEntry(new Path(AntlrCorePlugin.ANTLR_HOME + "/antlr.jar"),
                                        new Path(AntlrCorePlugin.ANTLR_HOME + "/antlrsrc.zip"), null));

                    if (!hasAntlrJar)
                        javaProject.setRawClasspath(
                                rawClasspath.toArray(new IClasspathEntry[rawClasspath.size()]), null);
                }
            }
        } catch (CoreException e) {
            AntlrCorePlugin.log(e);
        }
    }
}

From source file:org.antlr.eclipse.core.AntlrNature.java

License:Open Source License

/**
 * Remove the ANTLR nature from a project
 * @param aProject The project to remove the nature from
 * @param aMonitor A progress monitor/*  w ww . j a v a2  s. co m*/
 */
public static void removeNature(final IProject aProject, final IProgressMonitor aMonitor) {
    if (aProject != null) {
        if (DEBUG) {
            System.out.println("removing ANTLR nature from project '" + aProject.getName() + "'");
        }
        try {
            if (aProject.hasNature(ID)) {
                IProjectDescription desc = aProject.getDescription();
                ArrayList<String> natures = new ArrayList<String>(Arrays.asList(desc.getNatureIds()));
                natures.remove(ID);
                desc.setNatureIds(natures.toArray(new String[natures.size()]));
                aProject.setDescription(desc, aMonitor);

                // if it's a Java Project, remove the ANTLR_HOME class path variable
                if (aProject.hasNature(JavaCore.NATURE_ID)) {
                    IJavaProject javaProject = JavaCore.create(aProject);
                    ArrayList<IClasspathEntry> rawClasspath = new ArrayList<IClasspathEntry>(
                            Arrays.asList(javaProject.getRawClasspath()));
                    boolean hadAntlrJar = false;
                    for (Iterator<IClasspathEntry> i = rawClasspath.iterator(); i.hasNext();) {
                        IClasspathEntry entry = i.next();
                        if (entry.getEntryKind() == IClasspathEntry.CPE_VARIABLE) {
                            String segment0 = entry.getPath().segment(0);
                            if (AntlrCorePlugin.ANTLR_HOME.equals(segment0)) {
                                i.remove();
                                hadAntlrJar = true;
                            }
                            if ("PARSEVIEW_HOME".equals(segment0)) {
                                i.remove();
                                hadAntlrJar = true;
                            }
                        }
                    }
                    if (hadAntlrJar) {
                        javaProject.setRawClasspath(
                                rawClasspath.toArray(new IClasspathEntry[rawClasspath.size()]), null);
                    }
                }
            }
        } catch (CoreException e) {
            AntlrCorePlugin.log(e);
        }
    }
}

From source file:org.apache.felix.sigil.eclipse.internal.builders.SigilIncrementalProjectBuilder.java

License:Apache License

private void convert(IClasspathEntry cp, ISigilProjectModel sigil, List<File> files) throws CoreException {
    switch (cp.getEntryKind()) {
    case IClasspathEntry.CPE_PROJECT: {
        convertProject(cp, files);//w w w . jav  a 2  s .c  o  m
        break;
    }
    case IClasspathEntry.CPE_SOURCE: {
        convertSource(sigil, cp, files);
        break;
    }
    case IClasspathEntry.CPE_LIBRARY: {
        convertLibrary(sigil, cp, files);
        break;
    }
    case IClasspathEntry.CPE_VARIABLE:
        convertVariable(cp, files);
        break;
    }
}

From source file:org.apache.felix.sigil.eclipse.model.util.JavaHelper.java

License:Apache License

private static Collection<IClasspathEntry> newProjectEntry(ISigilProjectModel n, IAccessRule[] rules,
        IClasspathAttribute[] attributes, boolean export) throws CoreException {
    ArrayList<IClasspathEntry> entries = new ArrayList<IClasspathEntry>();
    entries.add(JavaCore.newProjectEntry(n.getProject().getFullPath(), rules, false, attributes, export));
    for (IClasspathEntry e : n.getJavaModel().getRawClasspath()) {
        String encoded = n.getJavaModel().encodeClasspathEntry(e);
        if (n.getBundle().getClasspathEntrys().contains(encoded)) {
            switch (e.getEntryKind()) {
            case IClasspathEntry.CPE_LIBRARY:
                entries.add(JavaCore.newLibraryEntry(e.getPath(), e.getSourceAttachmentPath(),
                        e.getSourceAttachmentRootPath(), rules, attributes, export));
                break;
            case IClasspathEntry.CPE_VARIABLE:
                IPath path = JavaCore.getResolvedVariablePath(e.getPath());
                if (path != null) {
                    IPath spath = e.getSourceAttachmentPath();
                    if (spath != null) {
                        spath = JavaCore.getResolvedVariablePath(spath);
                    }/*w  w w .ja  v  a  2s .c  o m*/

                    entries.add(JavaCore.newLibraryEntry(path, spath, e.getSourceAttachmentRootPath(), rules,
                            attributes, export));
                }
                break;
            }
        }
    }

    return entries;
}

From source file:org.apache.felix.sigil.eclipse.ui.internal.editors.project.ClasspathSection.java

License:Apache License

private void handleAdd() {
    try {/*  www .j a va 2 s.  co m*/
        BackgroundLoadingSelectionDialog<IClasspathEntry> dialog = new BackgroundLoadingSelectionDialog<IClasspathEntry>(
                getSection().getShell(), "Classpath Entry:", true);

        dialog.setDescriptor(new IElementDescriptor<IClasspathEntry>() {
            public String getName(IClasspathEntry element) {
                return element.getPath().toString();
            }

            public String getLabel(IClasspathEntry element) {
                return getName(element);
            }
        });

        dialog.setLabelProvider(new ModelLabelProvider());

        dialog.setFilter(new IFilter<IClasspathEntry>() {
            public boolean select(IClasspathEntry cp) {
                switch (cp.getEntryKind()) {
                case IClasspathEntry.CPE_LIBRARY:
                case IClasspathEntry.CPE_VARIABLE:
                case IClasspathEntry.CPE_SOURCE:
                    return !getBundle().getClasspathEntrys().contains(encode(cp));
                default:
                    return false;
                }
            }
        });

        dialog.setComparator(CLASSPATH_COMPARATOR);

        IClasspathEntry[] classpath = getProjectModel().getJavaModel().getRawClasspath();
        dialog.addElements(Arrays.asList(classpath));
        if (dialog.open() == Window.OK) {
            List<IClasspathEntry> selectedElements = dialog.getSelectedElements();

            Object[] added = selectedElements.toArray();
            for (IClasspathEntry entry : selectedElements) {
                getBundle().addClasspathEntry(encode(entry));
            }
            viewer.add(added);
            viewer.refresh();
            markDirty();
        }
    } catch (JavaModelException e) {
        ErrorDialog.openError(getSection().getShell(), "Error", null, e.getStatus());
    }
}

From source file:org.apache.felix.sigil.eclipse.ui.internal.editors.project.ClasspathSection.java

License:Apache License

private static int index(IClasspathEntry o1) {
    switch (o1.getEntryKind()) {
    case IClasspathEntry.CPE_SOURCE:
        return 0;
    case IClasspathEntry.CPE_PROJECT:
        return 1;
    case IClasspathEntry.CPE_LIBRARY:
        return 2;
    case IClasspathEntry.CPE_VARIABLE:
        return 3;
    case IClasspathEntry.CPE_CONTAINER:
        return 4;
    default://w  w  w .  j a va  2  s.c  om
        throw new IllegalStateException("Unknown classpath entry type " + o1);
    }
}

From source file:org.continuousassurance.swamp.eclipse.ImprovedClasspathHandler.java

License:Apache License

/**
 * Constructor for ImprovedClasspathHandler
 * @param project the Java project that we will generate a build file for
 * @param root the ImprovedClasspathHandler object for the project (this is the root of the recursive tree that we build from projects having dependencies)
 * @param exclSysLibs if true, Java system libraries get copied into the package at submission
 * @param subMonitor submonitor for tracking progress
 *///from   ww  w  .  j a va 2  s  .  c o  m
public ImprovedClasspathHandler(IJavaProject project, ImprovedClasspathHandler root, boolean exclSysLibs,
        SubMonitor subMonitor) {
    this.excludeSysLibs = exclSysLibs;
    sources = new ArrayList<IClasspathEntry>();
    libs = new ArrayList<IClasspathEntry>();
    systemLibs = new ArrayList<IClasspathEntry>();
    dependentProjects = new ArrayList<ImprovedClasspathHandler>();
    exportedEntries = new ArrayList<IClasspathEntry>();

    this.project = project;
    this.srcVersion = this.project.getOption(SOURCE_VERSION_OPTION, true);
    this.targetVersion = this.project.getOption(TARGET_VERSION_OPTION, true);

    if (root == null) {
        this.root = this;
        this.subMonitor = subMonitor;
        this.subMonitor.setWorkRemaining(100);
        visitedProjects = new HashMap<String, ImprovedClasspathHandler>();
        SWAMPBIN_PATH = setupBinDir(project.getProject());
        filesToArchive = new HashSet<String>();
    } else {
        this.root = root;
        visitedProjects = root.visitedProjects;
        SWAMPBIN_PATH = root.SWAMPBIN_PATH;
        filesToArchive = root.filesToArchive;
    }

    try {
        project.getProject().build(IncrementalProjectBuilder.CLEAN_BUILD, null);
    } catch (CoreException e1) {
        // TODO Auto-generated catch block
        System.err.println("Unable to do a clean build on the project for some reason");
        e1.printStackTrace();
    }

    IClasspathEntry[] entries = null;
    try {
        entries = project.getRawClasspath();
        if (entries == null || entries.length == 0) {
            return;
        }
    } catch (JavaModelException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
        return;
    }
    IWorkspaceRoot wsRoot = ResourcesPlugin.getWorkspace().getRoot();
    try {
        for (IClasspathEntry entry : entries) {
            int kind = entry.getEntryKind();
            if (this.subMonitor != null) {
                if (this.subMonitor.isCanceled()) {
                    System.out.println("Sub monitor got cancelled!");
                }
                this.subMonitor.split(100 / SwampSubmitter.CLASSPATH_ENTRY_TICKS);
            }
            if (kind == IClasspathEntry.CPE_SOURCE) {
                handleSource(entry, wsRoot);
            } else if (kind == IClasspathEntry.CPE_LIBRARY) {
                handleLibrary(entry, wsRoot);
            } else if (kind == IClasspathEntry.CPE_PROJECT) {
                handleProject(entry, wsRoot);
            } else if (kind == IClasspathEntry.CPE_VARIABLE) {
                handleVariable(entry, wsRoot);
            } else { // kind == IClasspathEntry.CPE_CONTAINER
                handleContainer(entry, wsRoot);
            }
        }
    } catch (IOException | JavaModelException e) {
        // TODO Report this error! This is very bad
        e.printStackTrace();
    }
    if (hasSwampbinDependencies) {
        filesToArchive.add(SWAMPBIN_PATH.toOSString());
    }
}

From source file:org.ebayopensource.vjet.eclipse.core.PiggyBackClassPathUtil.java

License:Open Source License

public static URL[] getProjectDependencyUrls_bak(List<IJavaProject> javaProjectList, List<URL> currentUrlList,
        HashMap<String, String> projectMap) throws JavaModelException, MalformedURLException {

    List<URL> projectDependencyUrlList = currentUrlList;

    if (projectDependencyUrlList == null) {
        projectDependencyUrlList = new ArrayList<URL>();
    }/*  w  ww  . j a  v  a  2 s .c om*/

    for (IJavaProject project : javaProjectList) {

        if (projectMap.containsKey(project.getElementName()) == true) {
            continue;
        } else {
            projectMap.put(project.getElementName(), project.getElementName());
        }

        // Add the dependencies to the URL list
        // IClasspathEntry[] entries;
        // entries = project.getResolvedClasspath(true);

        IClasspathEntry[] entries2;
        entries2 = project.getRawClasspath();

        for (IClasspathEntry entry : entries2) {

            IPath path = entry.getPath();
            File f = path.toFile();
            URL entryUrl;
            entryUrl = f.toURL();
            switch (entry.getEntryKind()) {

            case IClasspathEntry.CPE_VARIABLE:
            case IClasspathEntry.CPE_LIBRARY:
                addEntryToList(entry, projectDependencyUrlList);
            case IClasspathEntry.CPE_PROJECT:
                List<IJavaProject> subjavaProjectList = new ArrayList<IJavaProject>();
                IResource subResource = ResourcesPlugin.getWorkspace().getRoot().findMember(entry.getPath());
                if (subResource == null) {
                    String projectName = entry.getPath().toString();
                    String parentProjectName = project.getElementName();
                }
                if (subResource != null && subResource.getType() == IResource.PROJECT) {
                    IProject subProject = (IProject) subResource;
                    IJavaProject subJavaProject = JavaCore.create(subProject);
                    if (subJavaProject != null && subJavaProject.exists()) {
                        subjavaProjectList.add(subJavaProject);

                        // Recursively call our selves to populate the
                        // project
                        // dependency's for the sub projects.
                        getProjectDependencyUrls_bak(subjavaProjectList, projectDependencyUrlList, projectMap);
                    }

                }
                break;
            case IClasspathEntry.CPE_CONTAINER:
                if (!JavaRuntime.JRE_CONTAINER.equals(path.toOSString())) {
                    IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), project);
                    if (container != null) {
                        IClasspathEntry[] entries = container.getClasspathEntries();
                        for (int i = 0; i < entries.length; i++) {
                            addEntryToList(entries[i], projectDependencyUrlList);
                        }
                    }
                }
                break;
            default:
                break;
            }
        }
        //
        // IPath path = project.getOutputLocation();
        // IPath projectResourceLocation =
        // project.getResource().getLocation();
        // File projectFilePath = projectResourceLocation.append(
        // path.removeFirstSegments(1)).toFile();
        // URL projectOutputUrl;
        // projectOutputUrl = projectFilePath.toURL();
        //
        // if (projectDependencyUrlList.contains(projectOutputUrl) == false)
        // {
        // projectDependencyUrlList.add(projectOutputUrl);
        // }
    }

    URL[] arrayList = new URL[projectDependencyUrlList.size()];
    URL[] returnURLArray = projectDependencyUrlList.toArray(arrayList);

    return returnURLArray;

}

From source file:org.ebayopensource.vjet.eclipse.core.PiggyBackClassPathUtil.java

License:Open Source License

public static List<IBuildpathEntry> fetchBuildEntryFromJavaProject(IJavaProject javaProject) {
    // Project entry
    List<IBuildpathEntry> vEntries = new ArrayList<IBuildpathEntry>();
    List<String> duplicateChecker = new ArrayList<String>();
    IClasspathEntry[] entries2;//from  w  w  w .  j a v a 2s  .  c  om
    try {
        entries2 = javaProject.getRawClasspath();
    } catch (JavaModelException e) {
        VjetPlugin.error("Failed to resolve Java prjoect classpath: " + javaProject.getElementName(), e,
                IStatus.WARNING);
        return Collections.emptyList();
    }

    for (IClasspathEntry entry : entries2) {

        IPath path = entry.getPath();
        String sPath = path.toString();
        switch (entry.getEntryKind()) {

        case IClasspathEntry.CPE_VARIABLE:
        case IClasspathEntry.CPE_LIBRARY:
            addEntryToVJETEntry(entry, vEntries, duplicateChecker);
        case IClasspathEntry.CPE_PROJECT:
            IResource subResource = ResourcesPlugin.getWorkspace().getRoot().findMember(entry.getPath());
            if (subResource != null && subResource.getType() == IResource.PROJECT) {
                addProjectEntry(entry.getPath(), vEntries, duplicateChecker);
            }
            break;
        case IClasspathEntry.CPE_CONTAINER:
            if (!JavaRuntime.JRE_CONTAINER.equals(path.segment(0))) {

                IClasspathContainer container;
                try {
                    container = JavaCore.getClasspathContainer(path, javaProject);
                    if (container != null) {
                        IClasspathEntry[] entries = container.getClasspathEntries();
                        for (int i = 0; i < entries.length; i++) {
                            addEntryToVJETEntry(entries[i], vEntries, duplicateChecker);
                        }
                    }
                } catch (JavaModelException e) {
                    VjetPlugin.error("Failed to resolve Java classpath container: " + sPath, e,
                            IStatus.WARNING);
                }
            }
            break;
        default:
            break;
        }
    }
    return vEntries;
}

From source file:org.ebayopensource.vjet.eclipse.internal.launching.LauncherUtil.java

License:Open Source License

private static void getProjectDependentJars(Set<String> jars, IClasspathEntry[] classPathEntries) {
    if (classPathEntries != null) {
        for (IClasspathEntry classPathEntry : classPathEntries) {
            if (classPathEntry.getEntryKind() == IClasspathEntry.CPE_LIBRARY
                    || classPathEntry.getEntryKind() == IClasspathEntry.CPE_VARIABLE) {
                IPath path = JavaCore.getResolvedClasspathEntry(classPathEntry).getPath();
                if (path != null) {
                    String s = path.toString();
                    if (!StringUtils.isBlankOrEmpty(s)) {
                        jars.add(s);/* ww  w. j  a v a2s  .  c  o  m*/
                    }
                }
            }
        }
    }
}

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

Introduction

Prototype

Document

Usage