Java tutorial
/******************************************************************************* * Copyright (c) 2001, 2005 IBM Corporation and others. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * IBM Corporation - initial API and implementation *******************************************************************************/ package org.eclipse.jem.workbench.utility; /* * $RCSfile: JemProjectUtilities.java,v $ $Revision: 1.15 $ $Date: 2011/03/30 21:01:20 $ */ import java.net.URL; import java.util.*; import org.eclipse.core.resources.*; import org.eclipse.core.runtime.*; import org.eclipse.jdt.core.*; import org.eclipse.jem.internal.plugin.JavaEMFNature; import org.eclipse.jem.java.JavaClass; import org.eclipse.jem.java.JavaRefFactory; import org.eclipse.jem.util.emf.workbench.ProjectUtilities; import org.eclipse.jem.util.emf.workbench.WorkbenchResourceHelperBase; import org.eclipse.jem.util.emf.workbench.nature.EMFNature; import org.eclipse.jem.util.plugin.JEMUtilPlugin; /** * Project Utilities for JEM and Java. * * @since 1.1.0 */ public class JemProjectUtilities extends ProjectUtilities { private JemProjectUtilities() { } /** * The nature id for JEM Nature. * * @since 1.1.0 */ public static final String JEM_EMF_NatureID = IJavaEMFNature.NATURE_ID; /** * Get the EMF nature for JEM for the project. * @param project * @param addNature <code>true</code> if add the nature to the project if not set. <code>false</code> if don't add nature if not already on project. * @return the EMFNature or <code>null</code> if not found and addNature was <code>false</code> or it was not a java project. * @throws CoreException * * @since 1.1.0 */ public static EMFNature getJEM_EMF_Nature(IProject project, boolean addNature) throws CoreException { return addNature ? JavaEMFNature.createRuntime(project) : JavaEMFNature.getRuntime(project); } /** * Get the JavaClass from an IFile. * @param aFile * @return * * @since 1.1.0 */ public static JavaClass getJavaClass(IFile aFile) { if (aFile == null) return null; IProject project = aFile.getProject(); List folders = getSourceContainers(project); folders.addAll(getLibraryContainers(project)); IContainer folder = null; IPath folderPath, filePath, javaPath; filePath = aFile.getProjectRelativePath(); for (int i = 0; i < folders.size(); i++) { folder = (IContainer) folders.get(i); folderPath = folder.getProjectRelativePath(); int segments = filePath.matchingFirstSegments(folderPath); if (segments > 0) { javaPath = filePath.removeFirstSegments(segments); javaPath = javaPath.removeFileExtension(); String qualifiedName = javaPath.toString().replace('/', '.'); return (JavaClass) JavaRefFactory.eINSTANCE.reflectType(qualifiedName, WorkbenchResourceHelperBase.getResourceSet(project)); } } return null; } /** * Get source containers for the project. * * @param p * project * @return list of source containers. * * @since 1.0.0 */ public static List getSourceContainers(IProject p) { try { List sourceContainers = new ArrayList(); List sourcePaths = getSourcePaths(p); if (sourcePaths != null && !sourcePaths.isEmpty()) { for (int i = 0; i < sourcePaths.size(); i++) { IPath path = (IPath) sourcePaths.get(i); if (path.isEmpty()) sourceContainers.add(p); else sourceContainers.add(p.getFolder(path)); } } return sourceContainers; } catch (IllegalArgumentException ex) { return Collections.EMPTY_LIST; } } protected static List getSourcePaths(IProject p) { IJavaProject javaProj = getJavaProject(p); if (javaProj == null) return null; IClasspathEntry[] cp = null; try { cp = javaProj.getRawClasspath(); } catch (JavaModelException ex) { JEMUtilPlugin.getLogger().logError(ex); return null; } List sourcePaths = new ArrayList(); for (int i = 0; i < cp.length; i++) { if (cp[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) { sourcePaths.add(cp[i].getPath().removeFirstSegments(1)); } } return sourcePaths; } /** * Return list of IContainers that are Libraries in the classpath. * * @param p * project * @return list of library IContainers. * * @since 1.0.0 */ public static List getLibraryContainers(IProject p) { try { List libraryContainers = new ArrayList(); List libraryPaths = getlibraryPaths(p); if (libraryPaths != null && !libraryPaths.isEmpty()) { for (int i = 0; i < libraryPaths.size(); i++) { IPath path = (IPath) libraryPaths.get(i); if (path.isEmpty()) libraryContainers.add(p); else libraryContainers.add(p.getFolder(path)); } } return libraryContainers; } catch (IllegalArgumentException ex) { return Collections.EMPTY_LIST; } } protected static List getlibraryPaths(IProject p) { IJavaProject javaProj = getJavaProject(p); if (javaProj == null) return null; IClasspathEntry[] cp = null; try { cp = javaProj.getRawClasspath(); } catch (JavaModelException ex) { JEMUtilPlugin.getLogger().logError(ex); return null; } List libraryPaths = new ArrayList(); for (int i = 0; i < cp.length; i++) { if (cp[i].getEntryKind() == IClasspathEntry.CPE_LIBRARY) { libraryPaths.add(cp[i].getPath().removeFirstSegments(1)); } } return libraryPaths; } /** * Get the java project nature for the given project. * * @param p * project * @return the java project nature for the project or <code>null</code> if not a java project. * * @since 1.0.0 */ public static IJavaProject getJavaProject(IProject p) { if (p != null) { try { return (IJavaProject) p.getNature(JavaCore.NATURE_ID); } catch (CoreException ignore) { return null; } } return null; } /** * Touch classpath. It simply takes the classpath and sets it back in. * * @param javaProject * @throws JavaModelException * * @since 1.0.0 */ public static void updateClasspath(IJavaProject javaProject) throws JavaModelException { if (javaProject != null) javaProject.setRawClasspath(javaProject.getRawClasspath(), new NullProgressMonitor()); } /** * Return the location of the binary output files for the JavaProject. * * @param p * project * @return path to binary output folder or <code>null</code> if not java project or other problem. * * @since 1.0.0 */ public static IPath getJavaProjectOutputLocation(IProject p) { try { IJavaProject javaProj = getJavaProject(p); if (javaProj == null) return null; if (!javaProj.isOpen()) javaProj.open(null); return javaProj.readOutputLocation(); } catch (JavaModelException e) { return null; } } /** * Get the project's binary output container. * * @param p * project * @return project's output container or <code>null</code> if not java project or some other error. * * @since 1.0.0 */ public static IContainer getJavaProjectOutputContainer(IProject p) { IPath path = getJavaProjectOutputLocation(p); if (path == null) return null; if (path.segmentCount() == 1) return p; return p.getFolder(path.removeFirstSegments(1)); } /** * Get the binary output absolute (local file system) path. * * @param p * project * @return project's output path or <code>null</code> if not java project or some other error. * * @since 1.0.0 */ public static IPath getJavaProjectOutputAbsoluteLocation(IProject p) { IContainer container = getJavaProjectOutputContainer(p); if (container != null) return container.getLocation(); return null; } /** * Get the JDT JavaModel. * * @return JDT's JavaModel * * @since 1.0.0 */ public static IJavaModel getJavaModel() { return JavaCore.create(ResourcesPlugin.getWorkspace().getRoot()); } /** * Get all source package fragment roots. * * @param javaProj * @return source package fragment roots * @throws JavaModelException * * @since 1.0.0 */ public static List getSourcePackageFragmentRoots(IJavaProject javaProj) throws JavaModelException { List result = new ArrayList(); IPackageFragmentRoot[] roots = javaProj.getPackageFragmentRoots(); for (int i = 0; i < roots.length; i++) { IPackageFragmentRoot root = roots[i]; if (root.getKind() == IPackageFragmentRoot.K_SOURCE) result.add(root); } return result; } /** * Remove the resource from the classpath * * @param p * project * @param res * resource * @throws JavaModelException * * @since 1.0.0 */ public static void removeFromJavaClassPath(IProject p, IResource res) throws JavaModelException { IClasspathEntry entry = JavaCore.newLibraryEntry(res.getFullPath(), null, null); removeFromJavaClassPath(p, entry); } /** * Remove the path from the classpath * * @param p * project * @param path * path to remove * @throws JavaModelException * * @since 1.0.0 */ public static void removeFromJavaClassPath(IProject p, IPath path) throws JavaModelException { org.eclipse.core.resources.IFile f = p.getFile(path); removeFromJavaClassPath(p, f); } /** * Remove the classpath entry from the project's classpath. * * @param p * @param entry * @throws JavaModelException * * @since 1.0.0 */ public static void removeFromJavaClassPath(IProject p, IClasspathEntry entry) throws JavaModelException { IJavaProject javaProject = null; try { javaProject = (IJavaProject) p.getNature(JavaCore.NATURE_ID); } catch (CoreException ignore) { } if (javaProject != null) { IClasspathEntry[] classpath = javaProject.getRawClasspath(); javaProject.setRawClasspath(primRemoveFromJavaClassPath(classpath, entry), new NullProgressMonitor()); } } /** * Remove the list of entries from the classpath of the project. * * @param p * project * @param entries * list of IClassPathEntry's * @throws JavaModelException * * @since 1.0.0 */ public static void removeFromJavaClassPath(IProject p, List entries) throws JavaModelException { IJavaProject javaProject = null; try { javaProject = (IJavaProject) p.getNature(JavaCore.NATURE_ID); } catch (CoreException ignore) { } if (javaProject != null) { IClasspathEntry[] classpath = javaProject.getRawClasspath(); javaProject.setRawClasspath(primRemoveFromJavaClassPath(classpath, entries), new NullProgressMonitor()); } } protected static IClasspathEntry[] primRemoveFromJavaClassPath(IClasspathEntry[] classpath, IClasspathEntry entry) throws JavaModelException { List result = new ArrayList(); boolean didRemove = false; for (int i = 0; i < classpath.length; i++) { IClasspathEntry cpEntry = classpath[i]; if (!entry.getPath().equals(classpath[i].getPath())) result.add(cpEntry); else didRemove = true; } if (!didRemove) return classpath; return (IClasspathEntry[]) result.toArray(new IClasspathEntry[result.size()]); } protected static IClasspathEntry[] primRemoveFromJavaClassPath(IClasspathEntry[] classpath, List entries) throws JavaModelException { List arrayList = Arrays.asList(classpath); List removeable = new ArrayList(arrayList); IClasspathEntry entry; boolean didRemove = false; int size = entries.size(); for (int i = 0; i < size; i++) { entry = (IClasspathEntry) entries.get(i); for (int j = 0; j < classpath.length; j++) { IClasspathEntry cpEntry = classpath[j]; if (entry.getPath().equals(classpath[j].getPath())) { if (removeable.remove(cpEntry)) didRemove = true; } } } if (!didRemove) return classpath; return (IClasspathEntry[]) removeable.toArray(new IClasspathEntry[removeable.size()]); } /** * Get the classpath as an array or URL's. * * @param javaProject * @return array of URL's or <code>null</code> if javaProject was <code>null</code>. * * @since 1.0.0 */ public static URL[] getClasspathAsURLArray(IJavaProject javaProject) { if (javaProject == null) return null; Set visited = new HashSet(); List urls = new ArrayList(20); collectClasspathURLs(javaProject, urls, visited, true); URL[] result = new URL[urls.size()]; urls.toArray(result); return result; } private static void collectClasspathURLs(IJavaProject javaProject, List urls, Set visited, boolean isFirstProject) { if (visited.contains(javaProject)) return; visited.add(javaProject); IPath outPath = getJavaProjectOutputAbsoluteLocation(javaProject.getProject()); outPath = outPath.addTrailingSeparator(); URL out = ProjectUtilities.createFileURL(outPath); urls.add(out); IClasspathEntry[] entries = null; try { entries = javaProject.getResolvedClasspath(true); } catch (JavaModelException e) { return; } IClasspathEntry entry; for (int i = 0; i < entries.length; i++) { entry = entries[i]; switch (entry.getEntryKind()) { case IClasspathEntry.CPE_LIBRARY: case IClasspathEntry.CPE_CONTAINER: case IClasspathEntry.CPE_VARIABLE: collectClasspathEntryURL(entry, urls); break; case IClasspathEntry.CPE_PROJECT: { if (isFirstProject || entry.isExported()) collectClasspathURLs(getJavaProject(entry), urls, visited, false); break; } } } } private static void collectClasspathEntryURL(IClasspathEntry entry, List urls) { IPath path = entry.getPath(); if (null == path.getDevice()) { // workspace resource - is the IPath a file, folder, or a class folder whose location is the project root? if (path.segmentCount() == 1) { // It's a class folder whose location is the project root path = ResourcesPlugin.getWorkspace().getRoot().getProject(path.lastSegment()).getLocation(); } else { // It's a file or folder - capture it's absolute location IFile jarFile = ResourcesPlugin.getWorkspace().getRoot().getFile(path); if (jarFile.exists()) { path = jarFile.getLocation(); } } } URL url = ProjectUtilities.createFileURL(path); if (url != null) urls.add(url); } private static IJavaProject getJavaProject(IClasspathEntry entry) { IProject proj = ResourcesPlugin.getWorkspace().getRoot().getProject(entry.getPath().segment(0)); if (proj != null) return getJavaProject(proj); return null; } /** * Is this project a binary project. * <p> * Typically a Java project is considered binary if it does not have a source entry in the classpath. * * @param project * Project to test * @return <code>true</code> if project is a binary project. */ public static boolean isBinaryProject(IProject aProject) { IJavaProject javaProj = getJavaProject(aProject); if (javaProj == null) return false; IClasspathEntry[] entries = null; entries = javaProj.readRawClasspath(); for (int i = 0; i < entries.length; i++) { IClasspathEntry entry = entries[i]; if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) return false; } return true; } /** * Append to java class path. * <p> * Append a list of IClasspathEntry's to the build path of the passed project. Updated to remove existing occurrences of the passed entries before * appending. * </p> * * @param p * project * @param appendClasspathEntries * list of entries * @throws JavaModelException * * @since 1.0.0 */ public static void appendJavaClassPath(IProject p, List appendClasspathEntries) throws JavaModelException { IJavaProject javaProject = null; try { javaProject = (IJavaProject) p.getNature(JavaCore.NATURE_ID); } catch (CoreException ignore) { } if (javaProject != null) { IClasspathEntry[] classpath = javaProject.getRawClasspath(); List newPathList = new ArrayList(classpath.length); for (int i = 0; i < classpath.length; i++) { IClasspathEntry entry = classpath[i]; // Skip entries which are in the append list if (appendClasspathEntries.indexOf(entry) < 0) newPathList.add(entry); } newPathList.addAll(appendClasspathEntries); IClasspathEntry[] newClasspath = (IClasspathEntry[]) newPathList .toArray(new IClasspathEntry[newPathList.size()]); javaProject.setRawClasspath(newClasspath, new NullProgressMonitor()); } } /** * Append classpath entry. * <p> * Append one IClasspathEntry to the build path of the passed project. If a classpath entry having the same path as the parameter already exists, * then does nothing. * </p> * * @param p * Project * @param newEntry * Entry * @throws JavaModelException * * @since 1.0.0 */ public static void appendJavaClassPath(IProject p, IClasspathEntry newEntry) throws JavaModelException { IJavaProject javaProject = getJavaProject(p); if (javaProject == null) return; IClasspathEntry[] classpath = javaProject.getRawClasspath(); List newPathList = new ArrayList(classpath.length); for (int i = 0; i < classpath.length; i++) { IClasspathEntry entry = classpath[i]; // fix dup class path entry for .JETEmitter project // Skip the entry to be added if it already exists if (Platform.getOS().equals(Platform.OS_WIN32)) { if (!entry.getPath().toString().equalsIgnoreCase(newEntry.getPath().toString())) newPathList.add(entry); else return; } else { if (!entry.getPath().equals(newEntry.getPath())) newPathList.add(entry); else return; } } newPathList.add(newEntry); IClasspathEntry[] newClasspath = (IClasspathEntry[]) newPathList .toArray(new IClasspathEntry[newPathList.size()]); javaProject.setRawClasspath(newClasspath, new NullProgressMonitor()); } /** * Return the source path matching the parameter; if the parameter is null, or if the source folder is not on the classpath, return the first * source path on the classpath * * @param p * project * @param defaultSourceName * source folder to find if on classpath, or if <code>null</code> the first folder * @return path searched for or <code>null</code> if not java project or some other problem. * * @since 1.0.0 */ public static IPath getSourcePathOrFirst(IProject p, String defaultSourceName) { IJavaProject javaProj = getJavaProject(p); if (javaProj == null) return null; IClasspathEntry[] cp = null; try { cp = javaProj.getRawClasspath(); } catch (JavaModelException ex) { JEMUtilPlugin.getLogger().logError(ex); return null; } IClasspathEntry firstSource = null; IPath defaultSourcePath = null; if (defaultSourceName != null) defaultSourcePath = ProjectUtilities.createPath(p, defaultSourceName); for (int i = 0; i < cp.length; i++) { if (cp[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) { if (firstSource == null) { firstSource = cp[i]; if (defaultSourcePath == null) break; } if (cp[i].getPath().equals(defaultSourcePath)) return defaultSourcePath.removeFirstSegments(1); } } if (firstSource == null) return null; if (firstSource.getPath().segment(0).equals(p.getName())) return firstSource.getPath().removeFirstSegments(1); return null; } /** * Hack to force a reload of the .classpath file * * @param project * project to reload * @since 1.0.0 */ public static void forceClasspathReload(IProject project) throws JavaModelException { IJavaProject javaProj = getJavaProject(project); if (javaProj != null) { IClasspathEntry[] entries = javaProj.readRawClasspath(); if (entries != null) { IPath output = javaProj.readOutputLocation(); if (output != null) javaProj.setRawClasspath(entries, output, null); } } } /** * Get the paths of all of the local jars in the classpath for the project. It does not recurse into referenced projects. * * @param proj * project to search (should be a java project). * @return A list of IPath, where each entry is a project relative path to a JAR contained in the project. */ public static List getLocalJARPathsFromClasspath(IProject proj) { IJavaProject javaProj = getJavaProject(proj); if (javaProj == null) return null; IPath projectPath = proj.getFullPath(); List result = new ArrayList(); IClasspathEntry[] entries = javaProj.readRawClasspath(); for (int i = 0; i < entries.length; i++) { IClasspathEntry entry = entries[i]; if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) { IPath path = entry.getPath(); int segments = path.matchingFirstSegments(projectPath); if (segments > 0) result.add(path.removeFirstSegments(segments)); } } return result; } /** * Return the source folder matching the parameter; if the parameter is null, or if the source folder is not on the classpath, return the first * source folder on the classpath * * @param p * project * @param defaultSourceName * source folder to find if on classpath, or if <code>null</code> the first folder * @return container searched for or <code>null</code> if not java project or some other problem. * * @since 1.0.0 */ public static IContainer getSourceFolderOrFirst(IProject p, String defaultSourceName) { try { IPath sourcePath = getSourcePathOrFirst(p, defaultSourceName); if (sourcePath == null) return null; else if (sourcePath.isEmpty()) return p; else return p.getFolder(sourcePath); } catch (IllegalArgumentException ex) { return null; } } /** * Returns a list of IFolder that represents each source folder in a java project * * @deprecated Use {@link #getSourceContainers(IProject)}because the project itself might be a source container * * @param p * project * @return * * @since 1.0.0 */ public static List getSourceFolders(IProject p) { try { List sourceFolders = new ArrayList(); List sourcePaths = getSourcePaths(p); if (sourcePaths != null && !sourcePaths.isEmpty()) { for (int i = 0; i < sourcePaths.size(); i++) { IPath path = (IPath) sourcePaths.get(i); if (!path.isEmpty()) sourceFolders.add(p.getFolder(path)); } } return sourceFolders; } catch (IllegalArgumentException ex) { return Collections.EMPTY_LIST; } } }