Example usage for org.eclipse.jdt.core IJavaProject getRawClasspath

List of usage examples for org.eclipse.jdt.core IJavaProject getRawClasspath

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.*
  5. IJavaProject
  6. getRawClasspath

Introduction

In this page you can find the example usage for org.eclipse.jdt.core IJavaProject getRawClasspath.

Prototype

IClasspathEntry[] getRawClasspath() throws JavaModelException;

Source Link

Document

Returns the raw classpath for the project, as a list of classpath entries.

Usage

From source file:cn.ieclipse.adt.ext.helpers.ProjectHelper.java

License:Apache License

public static boolean isContainerInClasspath(IJavaProject javaProject, IClasspathContainer container)
        throws JavaModelException {
    IClasspathEntry[] entries = javaProject.getRawClasspath();
    // IClasspathEntry[] temps = container.getClasspathEntries();
    boolean result = false;

    for (IClasspathEntry entry : entries) {
        if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER
                && entry.getPath().equals(container.getPath())) {
            result = true;//www .  j a  v a 2  s  .  c  om
            break;
        }
    }
    return result;
}

From source file:cn.ieclipse.adt.ext.helpers.ProjectHelper.java

License:Apache License

/**
 * Get all classpathentries for the given project.
 * //from  www  .j a v  a 2s  .  com
 * @param javaProject
 *            project to get the classpath for.
 * @return classpathentries
 */
private static String[] getJavaClasspath(IJavaProject javaProject) throws CoreException {
    List<String> classPath = new ArrayList<String>();
    String[] defaultClassPath = JavaRuntime.computeDefaultRuntimeClassPath(javaProject);
    classPath.addAll(Arrays.asList(defaultClassPath));

    // add CPE_CONTAINER classpathes
    IClasspathEntry[] rawClasspath = javaProject.getRawClasspath();
    for (IClasspathEntry entry : rawClasspath) {
        if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
            IClasspathContainer classpathContainer = JavaCore.getClasspathContainer(entry.getPath(),
                    javaProject);
            if (classpathContainer != null) {
                IClasspathEntry[] classpathEntries = classpathContainer.getClasspathEntries();
                for (IClasspathEntry cEntry : classpathEntries) {
                    classPath.add(cEntry.getPath().toOSString());
                }
            }
        }
    }
    return classPath.toArray(new String[] {});
}

From source file:cn.ieclipse.aorm.eclipse.helpers.IntentReflectionHelper.java

License:Apache License

/**
 * Get all classpathentries for the given project.
 * /*from   w  w w  . j av a 2  s . com*/
 * @param javaProject
 *            project to get the classpath for.
 * @return classpathentries
 */
private String[] getJavaClasspath(IJavaProject javaProject) throws CoreException {
    List<String> classPath = new ArrayList<String>();
    String[] defaultClassPath = JavaRuntime.computeDefaultRuntimeClassPath(javaProject);
    classPath.addAll(Arrays.asList(defaultClassPath));

    // add CPE_CONTAINER classpathes
    IClasspathEntry[] rawClasspath = javaProject.getRawClasspath();
    for (IClasspathEntry entry : rawClasspath) {
        if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
            IClasspathContainer classpathContainer = JavaCore.getClasspathContainer(entry.getPath(),
                    javaProject);
            if (classpathContainer != null) {
                IClasspathEntry[] classpathEntries = classpathContainer.getClasspathEntries();
                for (IClasspathEntry cEntry : classpathEntries) {
                    classPath.add(cEntry.getPath().toOSString());
                }
            }
        }
    }
    return classPath.toArray(new String[] {});
}

From source file:com.aerospike.project.wizards.NewAerospikeProjectWizard.java

License:Apache License

protected boolean generateJavaProject() {
    URL url = this.getClass().getResource("project.stg");
    final STGroup projectSTG = new STGroupFile(url.getPath());
    final String projectName = page.getProjectName();
    final String author = page.getAuthor();
    final String email = page.getEmail();
    final String artifactId = page.getArtifiactId();
    final String version = page.getVersion();
    final String packageString = page.getPackage();
    final String mainClass = page.getMainClassName();
    final String seedNode = page.getSeedNode();
    final String port = page.getPortString();
    final boolean generateMain = page.getGenerateMain();
    final boolean generateJUnit = page.getGenerateJUnit();
    IRunnableWithProgress op = new IRunnableWithProgress() {
        public void run(IProgressMonitor monitor) throws InvocationTargetException {
            try {
                //Create the project
                IProject project = createProject(projectName, monitor);
                project.setPersistentProperty(CoreActivator.SEED_NODE_PROPERTY, seedNode);
                project.setPersistentProperty(CoreActivator.PORT_PROPERTY, port);
                project.setPersistentProperty(CoreActivator.UDF_DIRECTORY, null);
                project.setPersistentProperty(CoreActivator.AQL_GENERATION_DIRECTORY, null);
                //make a java project
                IJavaProject javaProject = JavaCore.create(project);
                // create the classpath entries
                List<IClasspathEntry> entries = new ArrayList<IClasspathEntry>();
                IExecutionEnvironmentsManager executionEnvironmentsManager = JavaRuntime
                        .getExecutionEnvironmentsManager();
                IExecutionEnvironment[] executionEnvironments = executionEnvironmentsManager
                        .getExecutionEnvironments();
                for (IExecutionEnvironment iExecutionEnvironment : executionEnvironments) {
                    // We will look for JavaSE-1.6 as the JRE container to add to our classpath
                    if ("JavaSE-1.6".equals(iExecutionEnvironment.getId())) {
                        entries.add(JavaCore
                                .newContainerEntry(JavaRuntime.newJREContainerPath(iExecutionEnvironment)));
                        break;
                    } else if ("JavaSE-1.5".equals(iExecutionEnvironment.getId())) {
                        entries.add(JavaCore
                                .newContainerEntry(JavaRuntime.newJREContainerPath(iExecutionEnvironment)));
                        break;
                    }//from  ww  w . j a  v a 2  s .c  om
                }
                IClasspathEntry mavenEntry = JavaCore.newContainerEntry(
                        new Path("org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER"), new IAccessRule[0],
                        new IClasspathAttribute[] { JavaCore.newClasspathAttribute(
                                "org.eclipse.jst.component.dependency", "/WEB-INF/lib") },
                        false);
                entries.add(mavenEntry);
                javaProject.setRawClasspath(entries.toArray(new IClasspathEntry[entries.size()]), null);
                // create source folders
                IFolder srcMainJava = project.getFolder("src/main/java");
                createFolder(srcMainJava);
                IFolder srcMainResource = project.getFolder("src/main/resource");
                createFolder(srcMainResource);
                IFolder srcTestJava = project.getFolder("src/test/java");
                createFolder(srcTestJava);
                IFolder srcTestResource = project.getFolder("src/test/resource");
                createFolder(srcTestResource);
                // create aerospike folders
                IFolder srcUDF = project.getFolder(store.getString(PreferenceConstants.UDF_PATH));
                createFolder(srcUDF);
                IFolder srcGenerated = project.getFolder(store.getString(PreferenceConstants.GENERATION_PATH));
                createFolder(srcGenerated);
                IFolder srcAql = project.getFolder("aql");
                createFolder(srcAql);
                //
                IPackageFragmentRoot mainJava = javaProject.getPackageFragmentRoot(srcMainJava);
                IPackageFragmentRoot mainResource = javaProject.getPackageFragmentRoot(srcMainResource);
                IPackageFragmentRoot testJava = javaProject.getPackageFragmentRoot(srcTestJava);
                IPackageFragmentRoot testResource = javaProject.getPackageFragmentRoot(srcTestResource);
                IPackageFragmentRoot mainGenerated = javaProject.getPackageFragmentRoot(srcGenerated);
                IClasspathEntry[] oldEntries = javaProject.getRawClasspath();
                IClasspathEntry[] newEntries = new IClasspathEntry[oldEntries.length + 5];
                System.arraycopy(oldEntries, 0, newEntries, 0, oldEntries.length);
                newEntries[oldEntries.length] = JavaCore.newSourceEntry(mainJava.getPath());
                newEntries[oldEntries.length + 1] = JavaCore.newSourceEntry(mainResource.getPath());
                newEntries[oldEntries.length + 2] = JavaCore.newSourceEntry(testJava.getPath());
                newEntries[oldEntries.length + 3] = JavaCore.newSourceEntry(testResource.getPath());
                newEntries[oldEntries.length + 4] = JavaCore.newSourceEntry(mainGenerated.getPath());
                javaProject.setRawClasspath(newEntries, monitor);
                // create the pom.xml
                ST template = projectSTG.getInstanceOf("pom");
                template.add("name", projectName);
                template.add("artifactId", artifactId);
                template.add("version", version);
                template.add("author", author);
                template.add("email", email);
                template.add("mainClass", mainClass);
                template.add("package", packageString);
                createFile(project, null, "pom.xml", monitor, template);
                // create the log4J.properties
                template = projectSTG.getInstanceOf("log4J");
                template.add("package", packageString);
                template.add("mainClass", mainClass);
                createFile(project, srcMainJava, "log4j.properties", monitor, template);
                // create the .gitignore
                template = projectSTG.getInstanceOf("ignore");
                createFile(project, null, ".gitignore", monitor, template);
                // create the README
                template = projectSTG.getInstanceOf("readme");
                template.add("name", projectName);
                createFile(project, null, "README.md", monitor, template);
                // create package
                // create JUnit
                if (generateJUnit) {
                    IPackageFragment pack = javaProject.getPackageFragmentRoot(srcTestJava)
                            .createPackageFragment(packageString, false, null);
                    template = projectSTG.getInstanceOf("junit");
                    template.add("name", mainClass + "Test");
                    template.add("package", packageString);
                    template.add("classUnderTest", mainClass);
                    pack.createCompilationUnit(mainClass + "Test" + ".java", template.render(), false, monitor);
                }
                // create main class
                IPackageFragment pack = javaProject.getPackageFragmentRoot(srcMainJava)
                        .createPackageFragment(packageString, false, null);
                template = projectSTG.getInstanceOf("mainClass");
                template.add("name", mainClass);
                template.add("package", packageString);
                template.add("author", author);
                template.add("seedNode", seedNode);
                template.add("port", port);
                final ICompilationUnit cu = pack.createCompilationUnit(mainClass + ".java", template.render(),
                        false, monitor);
                // open editor on main class
                monitor.setTaskName("Opening file for editing...");
                getShell().getDisplay().asyncExec(new Runnable() {
                    public void run() {
                        IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow()
                                .getActivePage();
                        try {
                            IEditorPart editor = IDE.openEditor(page, (IFile) cu.getResource(), true);
                        } catch (PartInitException e) {
                        }
                    }
                });

            } catch (CoreException e) {
                throw new InvocationTargetException(e);
            } finally {
                monitor.done();
            }
        }
    };
    try {
        getContainer().run(true, false, op);
    } catch (InterruptedException e) {
        return false;
    } catch (InvocationTargetException e) {
        Throwable realException = e.getTargetException();
        MessageDialog.openError(getShell(), "Error", realException.getMessage());
        return false;
    }
    return true;
}

From source file:com.aliyun.odps.eclipse.create.wizard.ProjectNature.java

License:Apache License

/**
 * Configures an Eclipse project as a Map/Reduce project by adding the Hadoop libraries to a
 * project's classpath.//from w  w w  .  j a  v a 2s .c  o  m
 */
public void configure() throws CoreException {
    String path = project.getPersistentProperty(new QualifiedName(Activator.PLUGIN_ID, "ODPS.runtime.path"));

    File dir = new File(path);
    final ArrayList<File> coreJars = new ArrayList<File>();
    dir.listFiles(new FileFilter() {
        public boolean accept(File pathname) {
            String fileName = pathname.getName();

            // get the hadoop core jar without touching test or examples
            // older version of hadoop don't use the word "core" -- eyhung
            if ((fileName.indexOf("hadoop") != -1) && (fileName.endsWith("jar"))
                    && (fileName.indexOf("test") == -1) && (fileName.indexOf("examples") == -1)) {
                coreJars.add(pathname);
            }

            return false; // we don't care what this returns
        }
    });
    File dir2 = new File(path + File.separatorChar + "lib");
    if (dir2.exists() && dir2.isDirectory()) {
        dir2.listFiles(new FileFilter() {
            public boolean accept(File pathname) {
                if ((!pathname.isDirectory()) && (pathname.getName().endsWith("jar"))) {
                    coreJars.add(pathname);
                }

                return false; // we don't care what this returns
            }
        });
    }

    // Add Hadoop libraries onto classpath
    IJavaProject javaProject = JavaCore.create(getProject());
    // Bundle bundle = Activator.getDefault().getBundle();

    try {
        IClasspathEntry[] currentCp = javaProject.getRawClasspath();
        IClasspathEntry[] newCp = new IClasspathEntry[currentCp.length + coreJars.size() + 1];
        System.arraycopy(currentCp, 0, newCp, 0, currentCp.length);

        final Iterator<File> i = coreJars.iterator();
        int count = 0;
        while (i.hasNext()) {
            // for (int i = 0; i < s_coreJarNames.length; i++) {

            final File f = (File) i.next();
            // URL url = FileLocator.toFileURL(FileLocator.find(bundle, new
            // Path("lib/" + s_coreJarNames[i]), null));
            URL url = f.toURI().toURL();
            log.finer("hadoop library url.getPath() = " + url.getPath());

            newCp[newCp.length - 2 - count] = JavaCore.newLibraryEntry(new Path(url.getPath()), null, null);
            count++;
        }

        // add examples to class-path
        IPath sourceFolderPath = new Path(javaProject.getProject().getName()).makeAbsolute();
        IPath exampleSrc = sourceFolderPath.append(new Path(CONST.EXAMPLE_SRC_PATH));
        IPath exampleClasses = sourceFolderPath.append(new Path(CONST.EXAMPLE_BIN));
        IClasspathEntry exampleSrcEntry = JavaCore.newSourceEntry(exampleSrc, new IPath[] {}, exampleClasses);
        newCp[newCp.length - 1] = exampleSrcEntry;

        javaProject.setRawClasspath(newCp, new NullProgressMonitor());
    } catch (Exception e) {
        log.log(Level.SEVERE, "IOException generated in " + this.getClass().getCanonicalName(), e);
    }
}

From source file:com.amazonaws.eclipse.android.sdk.classpath.AwsAndroidSdkClasspathUtils.java

License:Open Source License

public static void addAwsAndroidSdkToProjectClasspath(IJavaProject javaProject, AbstractSdkInstall sdkInstall) {
    try {/*w w w . ja  va2 s . com*/
        AndroidSdkClasspathContainer classpathContainer = new AndroidSdkClasspathContainer(sdkInstall,
                javaProject.getProject());

        IClasspathEntry[] rawClasspath = javaProject.getRawClasspath();
        List<IClasspathEntry> newList = new ArrayList<IClasspathEntry>();
        for (IClasspathEntry entry : rawClasspath) {
            if (entry.getPath().equals(classpathContainer.getPath()) == false) {
                newList.add(entry);
            }
        }

        newList.add(JavaCore.newContainerEntry(classpathContainer.getPath()));

        javaProject.setRawClasspath(newList.toArray(new IClasspathEntry[newList.size()]), null);
    } catch (JavaModelException e) {
        String message = "Unable to add AWS SDK for Android to the project's classpath";
        IStatus status = new Status(IStatus.ERROR, AndroidSDKPlugin.PLUGIN_ID, message, e);
        StatusManager.getManager().handle(status, StatusManager.LOG);
    }
}

From source file:com.amazonaws.eclipse.elasticbeanstalk.webproject.CreateNewAwsJavaWebProjectRunnable.java

License:Open Source License

private IClasspathEntry findSdkClasspathEntry(IJavaProject javaProject) throws JavaModelException {
    IPath expectedPath = new AwsClasspathContainer(SdkManager.getInstance().getDefaultSdkInstall()).getPath();
    for (IClasspathEntry entry : javaProject.getRawClasspath()) {
        if (entry.getPath().equals(expectedPath))
            return entry;
    }/*from w  w  w.  ja v a  2  s .c o m*/

    return null;
}

From source file:com.amazonaws.eclipse.lambda.project.wizard.NewLambdaJavaFunctionProjectWizard.java

License:Open Source License

private static void addTestDirectoryToClasspath(IProject project) {

    try {//www  .  j a  v  a  2  s  .c  o  m
        IJavaProject javaProj = JavaCore.create(project);
        IFolder tstFolder = project.getFolder("tst");

        IPackageFragmentRoot tstRoot = javaProj.getPackageFragmentRoot(tstFolder);

        IClasspathEntry[] originalCp = javaProj.getRawClasspath();
        IClasspathEntry[] augmentedCp = new IClasspathEntry[originalCp.length + 1];
        System.arraycopy(originalCp, 0, augmentedCp, 0, originalCp.length);

        augmentedCp[originalCp.length] = JavaCore.newSourceEntry(tstRoot.getPath());

        javaProj.setRawClasspath(augmentedCp, null);

    } catch (Exception e) {
        LambdaPlugin.getDefault().warn("Failed to add tst directory to the classpath", e);
    }
}

From source file:com.amazonaws.eclipse.lambda.project.wizard.util.FunctionProjectUtil.java

License:Open Source License

private static void addTestDirectoryToClasspath(IProject project) {

    try {/*from   www .  ja  va 2s . c  om*/
        IJavaProject javaProj = JavaCore.create(project);
        IFolder tstFolder = project.getFolder("tst");

        IPackageFragmentRoot tstRoot = javaProj.getPackageFragmentRoot(tstFolder);

        if (javaProj.isOnClasspath(tstRoot))
            return;

        IClasspathEntry[] originalCp = javaProj.getRawClasspath();
        IClasspathEntry[] augmentedCp = new IClasspathEntry[originalCp.length + 1];
        System.arraycopy(originalCp, 0, augmentedCp, 0, originalCp.length);

        augmentedCp[originalCp.length] = JavaCore.newSourceEntry(tstRoot.getPath());
        javaProj.setRawClasspath(augmentedCp, null);

    } catch (Exception e) {
        LambdaPlugin.getDefault().warn("Failed to add tst directory to the classpath", e);
    }
}

From source file:com.amazonaws.eclipse.sdk.ui.classpath.AwsSdkClasspathUtils.java

License:Open Source License

/**
 * Modifies the classpath of the specified Java project to contain the classpath container
 * for the AWS SDK for Java./*  ww  w. ja v  a2 s .c  om*/
 * 
 * @param javaProject The Java project to modify.
 * @param sdkInstall The AWS SDK for Java installation to add.
 */
public static void addAwsSdkToProjectClasspath(IJavaProject javaProject, SdkInstall sdkInstall) {
    try {
        AwsClasspathContainer classpathContainer = new AwsClasspathContainer(sdkInstall);

        IClasspathEntry[] rawClasspath = javaProject.getRawClasspath();
        List<IClasspathEntry> newList = new ArrayList<IClasspathEntry>();
        for (IClasspathEntry entry : rawClasspath) {
            if (entry.getPath().equals(classpathContainer.getPath()) == false) {
                newList.add(entry);
            }
        }

        newList.add(JavaCore.newContainerEntry(classpathContainer.getPath()));

        javaProject.setRawClasspath(newList.toArray(new IClasspathEntry[newList.size()]), null);
    } catch (JavaModelException e) {
        e.printStackTrace();
    }
}