private static IClasspathEntry getReferencingClassPathEntry(IJavaProject referencingProject, IJavaProject referencedProject) throws JavaModelException { IClasspathEntry result = null; IPath path = referencedProject.getProject().getFullPath(); IClasspathEntry[] classpath = referencingProject.getResolvedClasspath(true); for (int i = 0; i < classpath.length; i++) { IClasspathEntry entry = classpath[i]; if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT && path.equals(entry.getPath())) { if (entry.isExported()) { return entry; } // Consider it as a candidate. May be there is another entry that is // exported. result = entry; } } return result; }
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; }
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; }
private static IClasspathEntry getClasspathEntry(IJavaProject project, IPath sourcePath) throws JavaModelException { sourcePath = project.getPath().append(sourcePath); IClasspathEntry[] cp = project.getRawClasspath(); for (int i = 0; i < cp.length; i++) { if (sourcePath.equals(cp[i].getPath())) return JavaCore.getResolvedClasspathEntry(cp[i]); } return null; }
private static void updateReferencedClasspathEntry(IJavaProject javaProject, IClasspathEntry newEntry, IProgressMonitor monitor) throws JavaModelException { List<IClasspathEntry> newEntries = updateElements(javaProject.getReferencedClasspathEntries(), newEntry, (entry) -> { return entry.getEntryKind() == newEntry.getEntryKind() && entry.getPath().equals(newEntry.getPath()); }); javaProject.setRawClasspath(javaProject.getRawClasspath(), newEntries.toArray(new IClasspathEntry[0]), javaProject.getOutputLocation(), monitor); }
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; }
@Override public boolean isBuildFile(IResource resource) { if (resource != null && resource.getType() == IResource.FILE && (resource.getName().endsWith(GRADLE_SUFFIX) || resource.getName().equals(GRADLE_PROPERTIES)) && resource.getProject() != null && ProjectUtils.isGradleProject(resource.getProject())) { try { if (!ProjectUtils.isJavaProject(resource.getProject())) { return true; } IJavaProject javaProject = JavaCore.create(resource.getProject()); IPath outputLocation = javaProject.getOutputLocation(); return outputLocation == null || !outputLocation.isPrefixOf(resource.getFullPath()); } catch (JavaModelException e) { JavaLanguageServerPlugin.logException(e.getMessage(), e); } } return false; }
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()) CoreUtility.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()); }
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 IPath getOutputLocation(IJavaProject javaProject) { try { return javaProject.getOutputLocation(); } catch (CoreException e) { IProject project= javaProject.getProject(); IPath projPath= project.getFullPath(); return projPath.append(PreferenceConstants.getPreferenceStore().getString(PreferenceConstants.SRCBIN_BINNAME)); } }
public static boolean isOnSourcePath(IPath sourcePath, IJavaProject project) throws JavaModelException { for (IClasspathEntry entry : project.getRawClasspath()) { if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE && entry.getPath().equals(sourcePath)) { return true; } } return false; }
private static void updateProjectClasspath(IJavaProject javaProject, IClasspathEntry newEntry, IProgressMonitor monitor) throws JavaModelException { List<IClasspathEntry> newEntries = updateElements(javaProject.getRawClasspath(), newEntry, (entry) -> { return entry.getEntryKind() == newEntry.getEntryKind() && entry.getPath().equals(newEntry.getPath()); }); JavaLanguageServerPlugin.logInfo("Update source attachment " + (newEntry.getSourceAttachmentPath() == null ? null : newEntry.getSourceAttachmentPath().toOSString()) + " to the file " + newEntry.getPath().toOSString()); javaProject.setRawClasspath(newEntries.toArray(new IClasspathEntry[0]), monitor); }
private static IJavaProject getJavaProject(String projectName) { IProject project= ResourcesPlugin.getWorkspace().getRoot().getProject(projectName); if (project == null) return null; IJavaProject result= JavaCore.create(project); if (result == null) return null; if (!result.exists()) return null; return result; }
private String getDefaultAntPath(IJavaProject project) { if (project != null) { // The Javadoc.xml file can only be stored locally. So if // the project isn't local then we can't provide a good // default location. IPath path= project.getProject().getLocation(); if (path != null) return path.append("javadoc.xml").toOSString(); //$NON-NLS-1$ } return ""; //$NON-NLS-1$ }
public static Map<File, IPackageFragmentRoot> getClasspath(IJavaProject project) throws JavaModelException { final Map<File, IPackageFragmentRoot> classpath = new LinkedHashMap<>(); for (IPackageFragmentRoot fragment : project.getPackageFragmentRoots()) { if (fragment.getKind() == IPackageFragmentRoot.K_BINARY) { File classpathLocation; if (fragment.isExternal()) { classpathLocation = fragment.getPath().toFile(); } else { classpathLocation = fragment.getResource().getLocation().toFile(); } classpath.put(classpathLocation, fragment); } } return classpath; }
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); }
protected URI computeTraceURI(URI uri, IJavaProject javaProject) throws JavaModelException { for (IPackageFragmentRoot root : javaProject.getPackageFragmentRoots()) if (root.getKind() == IPackageFragmentRoot.K_SOURCE) { URI prefix = URI.createPlatformResourceURI(root.getResource().getFullPath().addTrailingSeparator().toString(), true); if (isPrefix(prefix, uri)) return uri.deresolve(prefix).trimFragment().trimQuery(); } return super.getURIForTrace(uri); } }
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); }
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; }