private Set<String> outputFoldersForProject(final IJavaProject project) { final Set<String> outputFolders = new HashSet<String>(); final IPath projectLocation = projectLocationPath(project); try { final IPath defaultOutputLocation = project.getOutputLocation(); if (defaultOutputLocation != null) { final IPath fullPath = appendPathTo(projectLocation, defaultOutputLocation); if (fullPath.toFile().exists()) { outputFolders.add(fullPath.toOSString()); } } for (final IClasspathEntry entry : project.getRawClasspath()) { if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) { final IPath outputLocation = entry.getOutputLocation(); if (outputLocation != null) { final IPath fullPath = appendPathTo(projectLocation, outputLocation); if (fullPath.toFile().exists()) { outputFolders.add(fullPath.toOSString()); } } } } } catch (final JavaModelException ex) { FeatureEditorPlugin.instance() .warn("Could not get output folder location for project " + project.getElementName()); } return outputFolders; }
public static void addServletLibToWebInf(IProject project, IProgressMonitor monitor) { monitor = Util.getNonNullMonitor(monitor); try { monitor.beginTask("", 1); IJavaProject javaProject = JavaCore.create(project); IClasspathEntry[] oldClasspath = javaProject.getRawClasspath(); IClasspathEntry[] newClasspath = new IClasspathEntry[oldClasspath.length + 1]; System.arraycopy(oldClasspath, 0, newClasspath, 0, oldClasspath.length); IClasspathEntry gwtServletJarEntry = JavaCore.newVariableEntry(Util.getGwtServletLibPath(), null, null); IClasspathAttribute attr = JavaCore.newClasspathAttribute("org.eclipse.jst.component.dependency", "/WEB-INF/lib"); gwtServletJarEntry = JavaCore.newVariableEntry( gwtServletJarEntry.getPath(), null, null, new IAccessRule[0], new IClasspathAttribute[] {attr}, false); newClasspath[oldClasspath.length] = gwtServletJarEntry; javaProject.setRawClasspath(newClasspath, monitor); } catch (JavaModelException e) { // the jar is already in the classpath. Activator.logException(e); } finally { monitor.done(); } }
protected void updateContainerAttributes( IProject project, IClasspathAttribute attributeToAdd, String attributeToDelete, IProgressMonitor monitor) throws JavaModelException { IJavaProject javaProject = JavaCore.create(project); if (javaProject == null) return; IClasspathEntry[] cp = javaProject.getRawClasspath(); for (int i = 0; i < cp.length; i++) { if (IClasspathEntry.CPE_CONTAINER == cp[i].getEntryKind() && BuildPathManager.isMaven2ClasspathContainer(cp[i].getPath())) { LinkedHashMap<String, IClasspathAttribute> attrs = new LinkedHashMap<String, IClasspathAttribute>(); for (IClasspathAttribute attr : cp[i].getExtraAttributes()) { if (!attr.getName().equals(attributeToDelete)) { attrs.put(attr.getName(), attr); } } attrs.put(attributeToAdd.getName(), attributeToAdd); IClasspathAttribute[] newAttrs = attrs.values().toArray(new IClasspathAttribute[attrs.size()]); cp[i] = JavaCore.newContainerEntry( cp[i].getPath(), cp[i].getAccessRules(), newAttrs, cp[i].isExported()); break; } } javaProject.setRawClasspath(cp, monitor); }
public void testConfigureSetsIgnoreWarningsForGenFolder() throws Exception { IJavaProject project = JavaCore.create(importAndroidProject("ignore-gen-warnings")); IClasspathEntry gen = findSourceEntry(project.getRawClasspath(), "gen"); assertTrue( "external assets folder isn't linked", booleanAttribute(IGNORE_OPTIONAL_PROBLEMS, gen)); }
public static void addUserLibToClassPath(IProject project, IProgressMonitor monitor) { monitor = Util.getNonNullMonitor(monitor); try { IJavaProject javaProject = JavaCore.create(project); IClasspathEntry[] oldClasspath = javaProject.getRawClasspath(); IClasspathEntry[] newClasspath = new IClasspathEntry[oldClasspath.length + 1]; System.arraycopy(oldClasspath, 0, newClasspath, 0, oldClasspath.length); IClasspathEntry gwtuserJarEntry = JavaCore.newVariableEntry(Util.getGwtUserLibPath(), null, null); gwtuserJarEntry = JavaCore.newVariableEntry( gwtuserJarEntry.getPath(), null, null, new IAccessRule[0], new IClasspathAttribute[0], false); newClasspath[oldClasspath.length] = gwtuserJarEntry; javaProject.setRawClasspath(newClasspath, monitor); } catch (CoreException e) { // the jar is already in the classpath. Activator.logException(e); } finally { monitor.done(); } }
/** * Checks if all source files are existing. If not, create them. * * @param javaProj */ private void checkSourceFolders(final IJavaProject javaProj) { if (javaProj == null) return; if (javaProj.exists()) { try { if (!javaProj.isOpen()) { javaProj.open(new NullProgressMonitor()); } IClasspathEntry[] entries = javaProj.getRawClasspath(); for (IClasspathEntry entry : entries) { if (IClasspathEntry.CPE_SOURCE == entry.getEntryKind()) { IPath path = entry.getPath(); final IPath folderPath = path.removeFirstSegments(1); if (!folderPath.isEmpty()) { Display.getDefault() .asyncExec( new Runnable() { public void run() { try { ImportUtils.createFolders( javaProj.getProject(), folderPath, IResource.FORCE); } catch (CoreException e) { _log.error(e.getMessage()); } } }); } } } } catch (JavaModelException e) { _log.error("findProjectSources: Could not retrieve project sources:", e); // $NON-NLS-1$ } } }
public void testRemoveFromBuildpath01RemoveLibs() throws Exception { fJavaProject = createProject(DEFAULT_OUTPUT_FOLDER_NAME); IPath[] jarPaths = new IPath[] { JavaProjectHelper.MYLIB.makeAbsolute(), JavaProjectHelper.JUNIT_SRC_381.makeAbsolute() }; CPJavaProject cpProject = CPJavaProject.createFromExisting(fJavaProject); BuildpathDelta delta = ClasspathModifier.addExternalJars(jarPaths, cpProject); ClasspathModifier.commitClassPath(cpProject, null); CPListElement[] toRemove = {delta.getAddedEntries().get(0), delta.getAddedEntries().get(1)}; delta = ClasspathModifier.removeFromBuildpath(toRemove, cpProject); assertDeltaResources(delta, new IPath[0], new IPath[0], new IPath[0], new IPath[0]); assertDeltaDefaultOutputFolder( delta, fJavaProject.getPath().append(DEFAULT_OUTPUT_FOLDER_NAME)); assertDeltaRemovedEntries(delta, new IPath[] {toRemove[0].getPath(), toRemove[1].getPath()}); assertDeltaAddedEntries(delta, new IPath[0]); ClasspathModifier.commitClassPath(cpProject, null); IClasspathEntry[] classpathEntries = fJavaProject.getRawClasspath(); assertNumberOfEntries(classpathEntries, 1); }
public void testAddExternalJarBug132827() throws Exception { fJavaProject = createProject(DEFAULT_OUTPUT_FOLDER_NAME); IPath[] jarPaths = new IPath[] {JavaProjectHelper.MYLIB.makeAbsolute()}; CPJavaProject cpProject = CPJavaProject.createFromExisting(fJavaProject); ClasspathModifier.addExternalJars(jarPaths, cpProject); ClasspathModifier.commitClassPath(cpProject, null); cpProject = CPJavaProject.createFromExisting(fJavaProject); IStatus status = ClasspathModifier.checkAddExternalJarsPrecondition(jarPaths, cpProject); assertTrue(status.getSeverity() == IStatus.INFO); BuildpathDelta delta = ClasspathModifier.addExternalJars(jarPaths, cpProject); assertDeltaResources(delta, new IPath[0], new IPath[0], new IPath[0], new IPath[0]); assertDeltaDefaultOutputFolder(delta, fJavaProject.getOutputLocation()); assertDeltaRemovedEntries(delta, new IPath[0]); assertDeltaAddedEntries(delta, new IPath[0]); ClasspathModifier.commitClassPath(cpProject, null); IClasspathEntry[] classpathEntries = fJavaProject.getRawClasspath(); assertNumberOfEntries(classpathEntries, 2); assertIsOnBuildpath(classpathEntries, JavaProjectHelper.MYLIB.makeAbsolute()); }
public void testRemoveFromBuildpathBug153299Lib() throws Exception { fJavaProject = createProject(null); IPackageFragmentRoot p01 = JavaProjectHelper.addSourceContainer(fJavaProject, null, new IPath[] {new Path("src1/")}); CPJavaProject cpProject = CPJavaProject.createFromExisting(fJavaProject); IPath[] jarPaths = new IPath[] {JavaProjectHelper.MYLIB.makeAbsolute()}; ClasspathModifier.addExternalJars(jarPaths, cpProject); ClasspathModifier.commitClassPath(cpProject, null); cpProject = CPJavaProject.createFromExisting(fJavaProject); BuildpathDelta delta = ClasspathModifier.removeFromBuildpath( new CPListElement[] { CPListElement.createFromExisting(p01.getRawClasspathEntry(), fJavaProject) }, cpProject); assertDeltaResources(delta, new IPath[0], new IPath[] {}, new IPath[0], new IPath[0]); assertDeltaDefaultOutputFolder(delta, fJavaProject.getPath()); assertDeltaRemovedEntries(delta, new IPath[] {p01.getPath()}); assertDeltaAddedEntries(delta, new IPath[0]); ClasspathModifier.commitClassPath(cpProject, null); IClasspathEntry[] classpathEntries = fJavaProject.getRawClasspath(); assertNumberOfEntries(classpathEntries, 2); }
public void testRemoveFromBuildpath01() throws Exception { fJavaProject = createProject(DEFAULT_OUTPUT_FOLDER_NAME); IPackageFragmentRoot src1 = JavaProjectHelper.addSourceContainer(fJavaProject, "src1"); IPackageFragmentRoot src2 = JavaProjectHelper.addSourceContainer(fJavaProject, "src2"); CPJavaProject cpProject = CPJavaProject.createFromExisting(fJavaProject); CPListElement[] toRemove = new CPListElement[2]; toRemove[0] = CPListElement.createFromExisting(src1.getRawClasspathEntry(), fJavaProject); toRemove[1] = CPListElement.createFromExisting(src2.getRawClasspathEntry(), fJavaProject); BuildpathDelta delta = ClasspathModifier.removeFromBuildpath(toRemove, cpProject); assertDeltaResources( delta, new IPath[0], new IPath[] {src1.getPath(), src2.getPath()}, new IPath[0], new IPath[0]); assertDeltaDefaultOutputFolder( delta, fJavaProject.getPath().append(DEFAULT_OUTPUT_FOLDER_NAME)); assertDeltaRemovedEntries(delta, new IPath[] {src1.getPath(), src2.getPath()}); assertDeltaAddedEntries(delta, new IPath[0]); ClasspathModifier.commitClassPath(cpProject, null); IClasspathEntry[] classpathEntries = fJavaProject.getRawClasspath(); assertNumberOfEntries(classpathEntries, 1); }
// test that after a source folder is deleted, all // class files nd resources are removed from the // output folder public void testDeleteSourceFolder() throws Exception { IProject proj = createPredefinedProject("CopyDerived1"); getWorkspace().build(IncrementalProjectBuilder.FULL_BUILD, null); IJavaProject jProj = JavaCore.create(proj); IClasspathEntry[] classpath = jProj.getRawClasspath(); IClasspathEntry[] newClasspath = new IClasspathEntry[classpath.length - 1]; // remove the classpath entry corresponding to src for (int i = 0, j = 0; i < classpath.length; i++, j++) { if (classpath[i].getPath().lastSegment().toString().equals("src")) { j--; continue; } newClasspath[j] = classpath[i]; } jProj.setRawClasspath(newClasspath, true, null); proj.build(IncrementalProjectBuilder.FULL_BUILD, null); IFolder out = proj.getFolder("bin"); checkFolderIsNotDerived(out, ""); checkFileNoExist(out, "file.txt"); checkFileNoExist(out, "Nothing.class"); checkFileNoExist(out, "Nothing2.class"); checkFolderNoExist(out, "package1"); checkFileNoExist(out, "package1/file.txt"); checkFileNoExist(out, "package1/Nothing.class"); checkFileNoExist(out, "package1/Nothing2.class"); }
public void testEditOutputFolder01SetOutputFolderForSourceFolder() throws Exception { fJavaProject = createProject(DEFAULT_OUTPUT_FOLDER_NAME); IPackageFragmentRoot src = JavaProjectHelper.addSourceContainer(fJavaProject, "src"); IPath projectPath = fJavaProject.getProject().getFullPath(); IPath outputPath = projectPath.append("srcbin"); CPJavaProject cpProject = CPJavaProject.createFromExisting(fJavaProject); CPListElement element = cpProject.getCPElement( CPListElement.createFromExisting(src.getRawClasspathEntry(), fJavaProject)); IStatus status = ClasspathModifier.checkSetOutputLocationPrecondition(element, outputPath, false, cpProject); assertTrue(status.getMessage(), status.getSeverity() != IStatus.ERROR); BuildpathDelta delta = ClasspathModifier.setOutputLocation(element, outputPath, false, cpProject); assertDeltaResources(delta, new IPath[] {outputPath}, new IPath[0], new IPath[0], new IPath[0]); assertDeltaDefaultOutputFolder(delta, fJavaProject.getOutputLocation()); assertDeltaAddedEntries(delta, new IPath[0]); assertDeltaRemovedEntries(delta, new IPath[0]); ClasspathModifier.commitClassPath(cpProject, null); IClasspathEntry[] classpathEntries = fJavaProject.getRawClasspath(); assertNumberOfEntries(classpathEntries, 2); IClasspathEntry entry = classpathEntries[1]; assertTrue(src.getRawClasspathEntry() == entry); IPath location = entry.getOutputLocation(); assertTrue( "Output path is " + location + " expected was " + outputPath, outputPath.equals(location)); }
private void addSystemLibraries() throws JavaModelException { IClasspathEntry[] oldEntries = javaProject.getRawClasspath(); IClasspathEntry[] newEntries = new IClasspathEntry[oldEntries.length + 1]; System.arraycopy(oldEntries, 0, newEntries, 0, oldEntries.length); newEntries[oldEntries.length] = JavaRuntime.getDefaultJREContainerEntry(); javaProject.setRawClasspath(newEntries, null); }
public static boolean hasProjectDependencyProblem(IJavaProject javaProject) { IProject project = javaProject.getProject(); try { ResourceBuilderUtils.cleanProblemMarkers( project, new String[] {IRIMMarker.PROJECT_DEPENDENCY_PROBLEM_MARKER}, IResource.DEPTH_ONE); } catch (CoreException e) { _log.error(e); } IClasspathEntry[] classpathEntries = null; try { classpathEntries = javaProject.getRawClasspath(); } catch (JavaModelException e) { _log.error(e); return true; } IProject dependentProject = null; String projectName = null; boolean hasDependencyError = false; for (IClasspathEntry entry : classpathEntries) { if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) { projectName = entry.getPath().lastSegment(); dependentProject = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName); if (!isValidDependency(javaProject.getProject(), dependentProject) && !hasDependencyError) { hasDependencyError = true; } } } return hasDependencyError; }
private void restoreTestProject() throws Exception { IJavaProject javaProject = getRoot().getJavaProject(); if (javaProject.exists()) { IClasspathEntry srcEntry = getRoot().getRawClasspathEntry(); IClasspathEntry jreEntry = RefactoringTestSetup.getJRELibrary().getRawClasspathEntry(); IClasspathEntry[] cpes = javaProject.getRawClasspath(); ArrayList newCPEs = new ArrayList(); boolean cpChanged = false; for (int i = 0; i < cpes.length; i++) { IClasspathEntry cpe = cpes[i]; if (cpe.equals(srcEntry) || cpe.equals(jreEntry)) { newCPEs.add(cpe); } else { cpChanged = true; } } if (cpChanged) { IClasspathEntry[] newCPEsArray = (IClasspathEntry[]) newCPEs.toArray(new IClasspathEntry[newCPEs.size()]); javaProject.setRawClasspath(newCPEsArray, null); } Object[] nonJavaResources = javaProject.getNonJavaResources(); for (int i = 0; i < nonJavaResources.length; i++) { Object kid = nonJavaResources[i]; if (kid instanceof IResource) { IResource resource = (IResource) kid; if (!PROJECT_RESOURCE_CHILDREN.contains(resource.getName())) { JavaProjectHelper.delete(resource); } } } } }
public void testRemoveFromBuildpathBug153299Src() throws Exception { fJavaProject = createProject(null); // Use the old behavior in order to test the fallback code. Set to ERROR since 3.8. fJavaProject.setOption( JavaCore.CORE_OUTPUT_LOCATION_OVERLAPPING_ANOTHER_SOURCE, JavaCore.IGNORE); IPackageFragmentRoot p01 = JavaProjectHelper.addSourceContainer(fJavaProject, null, new IPath[] {new Path("src1/")}); JavaProjectHelper.addSourceContainer(fJavaProject, "src1"); CPJavaProject cpProject = CPJavaProject.createFromExisting(fJavaProject); BuildpathDelta delta = ClasspathModifier.removeFromBuildpath( new CPListElement[] { CPListElement.createFromExisting(p01.getRawClasspathEntry(), fJavaProject) }, cpProject); assertDeltaResources(delta, new IPath[0], new IPath[] {}, new IPath[0], new IPath[0]); assertDeltaDefaultOutputFolder( delta, fJavaProject.getPath().append(DEFAULT_OUTPUT_FOLDER_NAME)); assertDeltaRemovedEntries(delta, new IPath[] {p01.getPath()}); assertDeltaAddedEntries(delta, new IPath[0]); ClasspathModifier.commitClassPath(cpProject, null); IClasspathEntry[] classpathEntries = fJavaProject.getRawClasspath(); assertNumberOfEntries(classpathEntries, 2); }
private static ClassFileReader getClassFileReaderForClassName(String className, IProject project) throws JavaModelException, MalformedURLException { IJavaProject jp = JavaCore.create(project); File outputDirectory = convertPathToFile(project, jp.getOutputLocation()); File classFile = new File(outputDirectory, ClassUtils.getClassFileName(className)); if (classFile.exists() && classFile.canRead()) { try { return ClassFileReader.read(classFile); } catch (ClassFormatException e) { } catch (IOException e) { } } IClasspathEntry[] classpath = jp.getRawClasspath(); for (int i = 0; i < classpath.length; i++) { IClasspathEntry path = classpath[i]; if (path.getEntryKind() == IClasspathEntry.CPE_SOURCE) { outputDirectory = convertPathToFile(project, path.getOutputLocation()); classFile = new File(outputDirectory, ClassUtils.getClassFileName(className)); if (classFile.exists() && classFile.canRead()) { try { return ClassFileReader.read(classFile); } catch (ClassFormatException e) { } catch (IOException e) { } } } } return null; }
public void testCuGetClass2() throws Exception { // Test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=211037 // In 1.6, Object#getClass() declares return type Class<?>, but in 1.5, it's Class<? extends // Object>. performCuOK(); // Test the same with 1.5: IJavaProject project = RefactoringTestSetup.getProject(); ArrayList classpath = new ArrayList(Arrays.asList(project.getRawClasspath())); IClasspathEntry jreEntry = RefactoringTestSetup.getJRELibrary().getRawClasspathEntry(); classpath.remove(jreEntry); IClasspathEntry[] noRTJarCPEs = (IClasspathEntry[]) classpath.toArray(new IClasspathEntry[classpath.size()]); project.setRawClasspath(noRTJarCPEs, new NullProgressMonitor()); JavaProjectHelper.addRTJar15(project); try { performCuOK(); } finally { project.setRawClasspath(noRTJarCPEs, new NullProgressMonitor()); JavaProjectHelper.addRTJar16(project); } }
public void newResource(final IResource resource) { if (resource instanceof IFile && resource.getName().endsWith(".groovy") && !resource.getName().endsWith("Tests.groovy")) { // Only open resource if is in any source folder IJavaProject jp = JdtUtils.getJavaProject(project); if (jp != null) { try { for (IClasspathEntry entry : jp.getRawClasspath()) { if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) { if (entry.getPath() != null && entry.getPath().isPrefixOf(resource.getFullPath())) { Display.getDefault() .asyncExec( new Runnable() { public void run() { SpringUIUtils.openInEditor((IFile) resource, -1); } }); break; } } } } catch (JavaModelException e) { } } } }
protected void changeToExistingLibrary( Shell shell, IPath path, boolean isNew, final IJavaProject project) { try { IClasspathEntry[] entries = project.getRawClasspath(); int idx = indexOfClasspath(entries, path); if (idx == -1) { return; } IClasspathEntry[] res; if (isNew) { res = BuildPathDialogAccess.chooseContainerEntries(shell, project, entries); if (res == null) { return; } } else { IClasspathEntry resEntry = BuildPathDialogAccess.configureContainerEntry(shell, entries[idx], project, entries); if (resEntry == null) { return; } res = new IClasspathEntry[] {resEntry}; } final IClasspathEntry[] newEntries = new IClasspathEntry[entries.length - 1 + res.length]; System.arraycopy(entries, 0, newEntries, 0, idx); System.arraycopy(res, 0, newEntries, idx, res.length); System.arraycopy(entries, idx + 1, newEntries, idx + res.length, entries.length - idx - 1); IRunnableContext context = JavaPlugin.getActiveWorkbenchWindow(); if (context == null) { context = PlatformUI.getWorkbench().getProgressService(); } context.run( true, true, new IRunnableWithProgress() { public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException { try { project.setRawClasspath(newEntries, project.getOutputLocation(), monitor); } catch (CoreException e) { throw new InvocationTargetException(e); } } }); } catch (JavaModelException e) { String title = NewWizardMessages.UserLibraryMarkerResolutionGenerator_error_title; String message = NewWizardMessages.UserLibraryMarkerResolutionGenerator_error_creationfailed_message; ExceptionHandler.handle(e, shell, title, message); } catch (InvocationTargetException e) { String title = NewWizardMessages.UserLibraryMarkerResolutionGenerator_error_title; String message = NewWizardMessages.UserLibraryMarkerResolutionGenerator_error_applyingfailed_message; ExceptionHandler.handle(e, shell, title, message); } catch (InterruptedException e) { // user cancelled } }
public void testConfigureNonAndroidProjectDoesAddGenFolder() throws Exception { IProject project = importAndroidProject(SIMPLE_PROJECT_NAME); IJavaProject javaProject = JavaCore.create(project); for (IClasspathEntry entry : javaProject.getRawClasspath()) { assertFalse( "classpath contains reference to gen directory", entry.getPath().toOSString().contains("gen")); } }
public void addJar(Plugin plugin, String jar) throws MalformedURLException, IOException, JavaModelException { Path result = findFileInPlugin(plugin, jar); IClasspathEntry[] oldEntries = javaProject.getRawClasspath(); IClasspathEntry[] newEntries = new IClasspathEntry[oldEntries.length + 1]; System.arraycopy(oldEntries, 0, newEntries, 0, oldEntries.length); newEntries[oldEntries.length] = JavaCore.newLibraryEntry(result, null, null); javaProject.setRawClasspath(newEntries, null); }
public static IResource getSourceResource(IResource classFile) { try { if (isJavaProject(classFile) && classFile.getName().endsWith(CLASS_FILE_EXTENSION)) { IPath classFilePath = classFile.getFullPath(); String classFileName = null; IJavaProject project = getJavaProject(classFile); IPath defaultOutput = project.getOutputLocation(); if (defaultOutput.isPrefixOf(classFilePath)) { classFileName = classFilePath.removeFirstSegments(defaultOutput.segmentCount()).toString(); } else { for (IClasspathEntry entry : project.getRawClasspath()) { if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) { IPath output = entry.getOutputLocation(); if (output != null) { if (classFilePath.isPrefixOf(output)) { classFileName = classFilePath.removeFirstSegments(output.segmentCount()).toString(); } } } } } if (classFileName != null) { // Replace file extension String sourceFileName = classFileName.replace(".class", ".java"); for (IClasspathEntry entry : project.getRawClasspath()) { if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) { IPath path = entry.getPath().append(sourceFileName).removeFirstSegments(1); IResource resource = project.getProject().findMember(path); if (resource != null) { return resource; } } } } } } catch (JavaModelException e) { } return null; }
public static Optional<IClasspathEntry> getModelPathClasspathEntry(IJavaProject javaProject) { try { return Arrays.stream(javaProject.getRawClasspath()) .filter(classpathEntry -> classpathEntry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) .filter(classpathEntry -> classpathEntry.getPath().equals(Constants.MODELPATH)) .findFirst(); } catch (JavaModelException e) { return Optional.empty(); } }
/** * @param project * @return */ public static IClasspathEntry[] getClasspathEntries(IProject project) { if (project != null) { IJavaProject javaProject = JavaCore.create(project); try { IClasspathEntry[] classPathEntries = javaProject.getRawClasspath(); return classPathEntries; } catch (JavaModelException e) { } } return null; }
private IPackageFragmentRoot createSourceFolder() throws CoreException { IFolder folder = project.getFolder("src"); folder.create(false, true, null); IPackageFragmentRoot root = javaProject.getPackageFragmentRoot(folder); IClasspathEntry[] oldEntries = javaProject.getRawClasspath(); IClasspathEntry[] newEntries = new IClasspathEntry[oldEntries.length + 1]; System.arraycopy(oldEntries, 0, newEntries, 0, oldEntries.length); newEntries[oldEntries.length] = JavaCore.newSourceEntry(root.getPath()); javaProject.setRawClasspath(newEntries, null); return root; }
protected static IClasspathContainer getWebLibClasspathContainer(IJavaProject project) throws JavaModelException { IClasspathEntry[] entries = project.getRawClasspath(); for (int i = 0; i < entries.length; i++) { IClasspathEntry entry = entries[i]; if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER && "org.eclipse.jst.j2ee.internal.web.container".equals(entry.getPath().segment(0))) { return JavaCore.getClasspathContainer(entry.getPath(), project); } } return null; }
/** * @param javaProject * @param newEntry * @throws JavaModelException */ public static final void addToClasspath(IJavaProject javaProject, IClasspathEntry newEntry) throws JavaModelException { if (newEntry == null) { return; } IClasspathEntry[] oldEntries = javaProject.getRawClasspath(); IClasspathEntry[] newEntries = new IClasspathEntry[oldEntries.length + 1]; System.arraycopy(oldEntries, 0, newEntries, 0, oldEntries.length); newEntries[oldEntries.length] = newEntry; javaProject.setRawClasspath(newEntries, null); }
public void testEditOutputFolder04RemoveProjectAndExcludeOutput() throws Exception { fJavaProject = createProject(null); // Use the old behavior in order to test the fallback code. Set to ERROR since 3.8. fJavaProject.setOption( JavaCore.CORE_OUTPUT_LOCATION_OVERLAPPING_ANOTHER_SOURCE, JavaCore.IGNORE); JavaProjectHelper.addSourceContainer( fJavaProject, null, new IPath[] {new Path("src1/"), new Path("src2/")}); IPackageFragmentRoot src1 = JavaProjectHelper.addSourceContainer(fJavaProject, "src1"); IPackageFragmentRoot src2 = JavaProjectHelper.addSourceContainer(fJavaProject, "src2"); IPath projectPath = fJavaProject.getProject().getFullPath(); IPath outputPath = projectPath.append("src2").append(DEFAULT_OUTPUT_FOLDER_NAME); CPJavaProject cpProject = CPJavaProject.createFromExisting(fJavaProject); CPListElement element = cpProject.getCPElement( CPListElement.createFromExisting(src1.getRawClasspathEntry(), fJavaProject)); IStatus status = ClasspathModifier.checkSetOutputLocationPrecondition(element, outputPath, false, cpProject); assertTrue(status.getMessage(), status.getSeverity() == IStatus.INFO); BuildpathDelta delta = ClasspathModifier.setOutputLocation(element, outputPath, false, cpProject); assertDeltaResources(delta, new IPath[] {outputPath}, new IPath[0], new IPath[0], new IPath[0]); assertDeltaDefaultOutputFolder( delta, fJavaProject.getPath().append(DEFAULT_OUTPUT_FOLDER_NAME)); assertDeltaRemovedEntries(delta, new IPath[] {fJavaProject.getPath()}); assertDeltaAddedEntries(delta, new IPath[0]); ClasspathModifier.commitClassPath(cpProject, null); assertTrue( "Default output folder was not set to bin", fJavaProject .getOutputLocation() .equals(fJavaProject.getPath().append(DEFAULT_OUTPUT_FOLDER_NAME))); IClasspathEntry[] classpathEntries = fJavaProject.getRawClasspath(); assertNumberOfEntries(classpathEntries, 3); IClasspathEntry entry = classpathEntries[1]; assertTrue(src1.getRawClasspathEntry() == entry); IPath location = entry.getOutputLocation(); assertTrue( "Output path is " + location + " expected was " + outputPath, outputPath.equals(location)); entry = classpathEntries[2]; assertTrue(src2.getRawClasspathEntry() == entry); IPath[] exclusionPatterns = entry.getExclusionPatterns(); assertTrue(exclusionPatterns.length == 1); assertTrue(exclusionPatterns[0].toString().equals("bin/")); }
private static IClasspathContainer allocateContainer( IJavaProject javaProject, List<IClasspathEntry> entries, IPath id, String description) { if (AndmoreAndroidPlugin.getDefault() == null) { // This is totally weird, but I've seen it happen! return null; } // First check that the project has a library-type container. try { IClasspathEntry[] rawClasspath = javaProject.getRawClasspath(); final IClasspathEntry[] oldRawClasspath = rawClasspath; boolean foundContainer = false; for (IClasspathEntry entry : rawClasspath) { // get the entry and kind final int kind = entry.getEntryKind(); if (kind == IClasspathEntry.CPE_CONTAINER) { String path = entry.getPath().toString(); String idString = id.toString(); if (idString.equals(path)) { foundContainer = true; break; } } } // if there isn't any, add it. if (foundContainer == false) { // add the android container to the array rawClasspath = ProjectHelper.addEntryToClasspath( rawClasspath, JavaCore.newContainerEntry(id, true /*isExported*/)); } // set the new list of entries to the project if (rawClasspath != oldRawClasspath) { javaProject.setRawClasspath(rawClasspath, new NullProgressMonitor()); } } catch (JavaModelException e) { // This really shouldn't happen, but if it does, simply return null (the calling // method will fails as well) return null; } return new AndroidClasspathContainer( entries.toArray(new IClasspathEntry[entries.size()]), id, description, IClasspathContainer.K_APPLICATION); }