private static IPath determinePackageName(IPath path) { if (path != null) { final IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(path.segment(0)); try { if (project != null && project.hasNature(JavaCore.NATURE_ID)) { final IJavaProject javaProject = JavaCore.create(project); for (final IClasspathEntry entry : javaProject.getRawClasspath()) { if (entry.getPath().isPrefixOf(path)) { return path.removeFirstSegments(entry.getPath().segmentCount()); } } } } catch (Exception e) { // Ignore the exceptions since they are not useful (hopefully) } } return null; }
private void setClasspath(IProject project, IFeatureModel model, IProgressMonitor monitor) throws JavaModelException { SubMonitor subMonitor = SubMonitor.convert(monitor); IJavaProject jProject = JavaCore.create(project); IClasspathEntry jreCPEntry = JavaCore.newContainerEntry(new Path("org.eclipse.jdt.launching.JRE_CONTAINER")); //$NON-NLS-1$ String libName = model.getFeature().getInstallHandler().getLibrary(); IClasspathEntry handlerCPEntry = JavaCore.newLibraryEntry(project.getFullPath().append(libName), null, null); jProject.setRawClasspath(new IClasspathEntry[] { jreCPEntry, handlerCPEntry }, subMonitor); }
public CodeFormatter(Map options) { if (options == null) { this.options = JavaCore.getOptions(); } else { this.options = options; } }
protected void adjustSourceCompatibility(String value) { Hashtable map = JavaCore.getOptions(); map.put(JavaCore.COMPILER_SOURCE, value); JavaCore.setOptions(map); }
private static IClasspathEntry getRealClasspathEntry(IJavaProject jproject, IPath containerPath, IPath libPath) throws JavaModelException { IClasspathContainer container= JavaCore.getClasspathContainer(containerPath, jproject); if (container != null) { IClasspathEntry[] entries= container.getClasspathEntries(); for (int i= 0; i < entries.length; i++) { IClasspathEntry curr= entries[i]; IClasspathEntry resolved= JavaCore.getResolvedClasspathEntry(curr); if (resolved != null && libPath.equals(resolved.getPath())) { return curr; // return the real entry } } } return null; // not found }
@Override public Object getNewElement() { IPath newPath= fProject.getPath().removeLastSegments(1).append(getNewElementName()); return JavaCore.create(ResourcesPlugin.getWorkspace().getRoot().findMember(newPath)); }
public static IJavaProject findJavaProject(String projectName) { IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); IProject project = root.getProject(projectName); if (project != null) return JavaCore.create(project); return null; }
public static class ClasspathResolutionBreakpointListener { public void breakpoint(int bp) { // override in listener implementation } }
public static boolean isInJavaOutput(IResource resource) { IProject project = resource.getProject(); IJavaProject javaProject = JavaCore.create(project); try { if (javaProject.exists() && project != project.getWorkspace().getRoot().findMember(javaProject.getOutputLocation()) && javaProject.getOutputLocation().isPrefixOf(resource.getFullPath())) { return true; } } catch (JavaModelException exception) { CodeGenPlugin.INSTANCE.log(exception); } return false; }
public static List<IJavaProject> getProjects() { final List<IJavaProject> openProjects = new ArrayList<>(); for (final org.eclipse.core.resources.IProject project : ResourcesPlugin.getWorkspace().getRoot().getProjects()) { if (project.isOpen()) { final IJavaProject javaProject = JavaCore.create(project); if (javaProject != null) { openProjects.add(javaProject); } } } return openProjects; }
public Set<IPackageFragmentRoot> getOverallScope( ILaunchConfiguration configuration) throws CoreException { final IJavaModel model = JavaCore.create(ResourcesPlugin.getWorkspace() .getRoot()); final Set<IPackageFragmentRoot> result = new HashSet<IPackageFragmentRoot>(); for (final IJavaProject project : model.getJavaProjects()) { if (project.getProject().hasNature(PLUGIN_NATURE)) { result.addAll(Arrays.asList(project.getPackageFragmentRoots())); } } return ScopeUtils.filterJREEntries(result); }
public IJavaProject getJavaProject(Project model) { for (IProject iproj : iworkspace.getRoot().getProjects()) { if (iproj.getName().equals(model.getName())) { IJavaProject ij = JavaCore.create(iproj); if (ij != null && ij.exists()) { return ij; } // current project is not a Java project } } return null; }
private static IClasspathEntry getClasspathEntryForMarker(final IMarker marker, final String cpEntryPath) throws CoreException { final IProject proj = marker.getResource().getProject(); if (proj != null && proj.hasNature(JavaCore.NATURE_ID)) { final IJavaProject jProject = JavaCore.create(proj); if (cpEntryPath != null) { IClasspathEntry[] rawCp = jProject.getRawClasspath(); for (int i = 0; i < rawCp.length; i++) { if (rawCp[i].getPath().toString().equals(cpEntryPath)) { return rawCp[i]; } } } } return null; }
private void createPackageFragmentRoot(IPackageFragmentRoot root) throws CoreException { final IJavaProject project= root.getJavaProject(); if (!project.exists()) { // createJavaProject(project.getProject()); } final IFolder folder= project.getProject().getFolder(root.getElementName()); if (!folder.exists()) { ResourceUtil.createFolder(folder, true, true, new NullProgressMonitor()); } final List<IClasspathEntry> list= Arrays.asList(project.getRawClasspath()); list.add(JavaCore.newSourceEntry(folder.getFullPath())); project.setRawClasspath(list.toArray(new IClasspathEntry[list.size()]), new NullProgressMonitor()); }
private IJavaSearchScope createSearchScope() throws JavaModelException { IJavaProject[] projects = JavaCore.create(ResourcesPlugin.getWorkspace().getRoot()).getJavaProjects(); return SearchEngine.createJavaSearchScope(projects, IJavaSearchScope.SOURCES); } }
public static IContainer getOutputContainer(IProject project, IPackageFragmentRoot sourceContainer) { try { IJavaProject jProject = JavaCore.create(project); IPath outputPath = sourceContainer.getRawClasspathEntry().getOutputLocation(); if (outputPath == null) { if (jProject.getOutputLocation().segmentCount() == 1) return project; return project.getFolder(jProject.getOutputLocation().removeFirstSegments(1)); } return project.getFolder(outputPath.removeFirstSegments(1)); } catch (Exception e) { } return null; }
private static IFile getCandidate(IAdaptable element) throws JavaModelException { IResource resource = (IResource) element.getAdapter(IResource.class); if (!(resource instanceof IFile) || !ArchiveFileFilter.isArchivePath(resource.getFullPath())) return null; IJavaProject project = JavaCore.create(resource.getProject()); if (project != null && project.exists() && (project.findPackageFragmentRoot(resource.getFullPath()) == null)) return (IFile) resource; return null; }
private void updateClasspath(IPath newPath, IProgressMonitor monitor) throws JavaModelException { IClasspathEntry[] classpath= fProject.getRawClasspath(); IPath jreContainerPath= new Path(JavaRuntime.JRE_CONTAINER); for (int i= 0; i < classpath.length; i++) { IClasspathEntry curr= classpath[i]; if (curr.getEntryKind() == IClasspathEntry.CPE_CONTAINER && curr.getPath().matchingFirstSegments(jreContainerPath) > 0) { classpath[i]= JavaCore.newContainerEntry(newPath, curr.getAccessRules(), curr.getExtraAttributes(), curr.isExported()); } } fProject.setRawClasspath(classpath, monitor); }
private static void addReferencingProjects(IJavaProject focus, Set<IJavaProject> projects) throws JavaModelException { IProject[] referencingProjects= focus.getProject().getReferencingProjects(); for (int i= 0; i < referencingProjects.length; i++) { IJavaProject candidate= JavaCore.create(referencingProjects[i]); if (candidate == null || projects.contains(candidate) || !candidate.exists()) continue; // break cycle IClasspathEntry entry= getReferencingClassPathEntry(candidate, focus); if (entry != null) { projects.add(candidate); if (entry.isExported()) addReferencingProjects(candidate, projects); } } }
private void setClasspath(IProject project, IFieldData data) throws JavaModelException, CoreException { IJavaProject javaProject = JavaCore.create(project); // Set output folder if (data.getOutputFolderName() != null) { IPath path = project.getFullPath().append(data.getOutputFolderName()); javaProject.setOutputLocation(path, null); } IClasspathEntry[] entries = getClassPathEntries(javaProject, data); javaProject.setRawClasspath(entries, null); }