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

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

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

Introduction

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

Prototype

void setRawClasspath(IClasspathEntry[] entries, IProgressMonitor monitor) throws JavaModelException;

Source Link

Document

Sets the classpath of this project using a list of classpath entries.

Usage

From source file:ccw.wizards.NewClojureProjectWizard.java

License:Open Source License

private void setupJavaProjectClassPath(IJavaProject javaProject) throws CoreException {
    IClasspathEntry[] entriesOld = javaProject.getRawClasspath();
    IClasspathEntry[] entriesNew = new IClasspathEntry[entriesOld.length + 1];

    System.arraycopy(entriesOld, 0, entriesNew, 0, entriesOld.length);

    // Ensure a proper "src" directory is used for sources (and not the project)
    for (int i = 0; i < entriesOld.length; i++) {
        if (entriesOld[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) {
            IFolder src = javaProject.getProject().getFolder("src");
            if (!src.exists())
                src.create(true, true, null);
            entriesNew[i] = JavaCore.newSourceEntry(src.getFullPath());
        }/*from  w w w  . ja v  a  2s .  co m*/
    }

    entriesNew[entriesOld.length] = JavaCore
            .newContainerEntry(Path.fromPortableString(JavaRuntime.JRE_CONTAINER));

    javaProject.setRawClasspath(entriesNew, null);
    javaProject.save(null, true);
}

From source file:ch.mlutz.plugins.t4e.handlers.ClasspathContainerHandler.java

License:Open Source License

private Object onAddClasspathContainer(ExecutionEvent event) throws ExecutionException {

    // boolean oldValue = HandlerUtil.toggleCommandState(event.getCommand());

    String localRepositoryDir = MavenTools.getMavenLocalRepoPath();
    log.info("LocalRepositoryDir: " + localRepositoryDir);

    /*// w w w.  j  ava 2  s .com
         try {
    JavaCore.setClasspathContainer(containerSuggestion.getPath(), new IJavaProject[] {project},
       new IClasspathContainer[] {new Maven2ClasspathContainer(containerPath, bundleUpdater.newEntries)}, null);
         } catch(JavaModelException ex) {
    Maven2Plugin.getDefault().getConsole().logError(ex.getMessage());
         }
     */

    // get workbench window
    IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindowChecked(event);
    // set selection service
    ISelectionService service = window.getSelectionService();
    // set structured selection
    IStructuredSelection structured = (IStructuredSelection) service.getSelection();

    //check if it is an IFile
    Object el = structured.getFirstElement();

    if (el instanceof IJavaProject) {

        IJavaProject javaProject = (IJavaProject) el;

        // Create new Classpath Container Entry
        IClasspathEntry containerEntry = JavaCore.newContainerEntry(CONTAINER_PATH);

        // Initialize Classpath Container
        ClasspathContainerInitializer containerInit = JavaCore
                .getClasspathContainerInitializer(Constants.CONTAINER_ID);
        try {
            containerInit.initialize(new Path(Constants.CONTAINER_ID), javaProject);

            // Set Classpath of Java Project
            List<IClasspathEntry> projectClassPath = new ArrayList<IClasspathEntry>(
                    Arrays.asList(javaProject.getRawClasspath()));
            projectClassPath.add(containerEntry);
            javaProject.setRawClasspath(projectClassPath.toArray(new IClasspathEntry[projectClassPath.size()]),
                    null);
        } catch (CoreException e) {
            log.error("Could not add Classpath container: ", e);
        }

        /*
        IClasspathEntry varEntry = JavaCore.newContainerEntry(
              new Path("JDKLIB/default"), // container 'JDKLIB' + hint 'default'
              false); //not exported
                
        try {
           JavaCore.setClasspathContainer(
          new Path("JDKLIB/default"),
          new IJavaProject[]{ (IJavaProject) el }, // value for 'myProject'
          new IClasspathContainer[] {
             new IClasspathContainer() {
                public IClasspathEntry[] getClasspathEntries() {
                   return new IClasspathEntry[]{
                         JavaCore.newLibraryEntry(new Path("d:/rt.jar"), null, null, false)
                   };
                }
                public String getDescription() { return "Basic JDK library container"; }
                public int getKind() { return IClasspathContainer.K_SYSTEM; }
                public IPath getPath() { return new Path("JDKLIB/basic"); }
             }
          },
          null);
        } catch (JavaModelException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
        }
        */
    }
    return null;
}

From source file:ch.mlutz.plugins.t4e.handlers.ClasspathContainerHandler.java

License:Open Source License

private Object onRemoveClasspathContainer(ExecutionEvent event) throws ExecutionException {
    // get workbench window
    IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindowChecked(event);
    // set selection service
    ISelectionService service = window.getSelectionService();
    // set structured selection
    IStructuredSelection structured = (IStructuredSelection) service.getSelection();

    //check if it is an IFile
    Object el = structured.getFirstElement();

    if (el instanceof IJavaProject) {

        IJavaProject javaProject = (IJavaProject) el;

        try {/*w ww.  j a  va 2s  .com*/
            // Set Classpath of Java Project
            List<IClasspathEntry> projectClassPath = new ArrayList<IClasspathEntry>(
                    Arrays.asList(javaProject.getRawClasspath()));

            IClasspathEntry entry;
            for (int i = projectClassPath.size() - 1; i >= 0; --i) {
                entry = projectClassPath.get(i);
                if (entry.getPath().equals(CONTAINER_PATH)) {
                    projectClassPath.remove(i);
                }
            }

            javaProject.setRawClasspath(projectClassPath.toArray(new IClasspathEntry[projectClassPath.size()]),
                    null);
        } catch (CoreException e) {
            log.error("Could not remove Classpath container: ", e);
        }
    }
    return null;
}

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

License:Apache License

public static void cleanOrmClasspath(IJavaProject javaProject) throws JavaModelException {
    IClasspathEntry[] entries = javaProject.getRawClasspath();
    int idx = -1;
    int i = 0;//from w w w  .  j  a  v  a2s . c o m
    for (IClasspathEntry entry : entries) {
        if (AormClasspathContainerInitializer.invalidOrmClassPath(entry.getPath())) {
            idx = i;
            break;
        }
        i++;
    }
    if (idx >= 0) {
        entries = removeEntryFromClasspath(entries, idx);
        javaProject.setRawClasspath(entries, new NullProgressMonitor());
    }
}

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

License:Apache License

public static void addOrRemoveEntryToClasspath(IJavaProject javaProject, IClasspathEntry newEntry)
        throws JavaModelException {
    int idx = isEntryInClasspath(javaProject, newEntry);
    IClasspathEntry[] entries = javaProject.getRawClasspath();
    if (idx >= 0) {
        entries = removeEntryFromClasspath(entries, idx);
    } else {/*from  w  w w. j  a v  a2  s.c o  m*/
        entries = addEntryToClasspath(entries, newEntry);
    }
    javaProject.setRawClasspath(entries, new NullProgressMonitor());
}

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;
                    }/*w  w  w. ja  v a 2s. c o  m*/
                }
                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 va2s.com*/
 */
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  ww .  j  a va2 s  .  c o  m*/
        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.lambda.project.wizard.NewLambdaJavaFunctionProjectWizard.java

License:Open Source License

private static void addTestDirectoryToClasspath(IProject project) {

    try {// www.ja v  a2s  . com
        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 w  ww  .  j av  a 2s  . c  o  m*/
        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);
    }
}