Java tutorial
/******************************************************************************* * Copyright (c) 2004, 2013 Richard Hoefter 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: * Richard Hoefter (richard.hoefter@web.de) - initial API and implementation, bug 95298, bug 192726, bug 201180 * IBM Corporation - nlsing and incorporating into Eclipse, bug 108276 *******************************************************************************/ package org.eclipse.ant.internal.ui.datatransfer; import java.io.File; import java.net.URI; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import org.eclipse.ant.internal.core.IAntCoreConstants; import org.eclipse.ant.internal.ui.AntUIPlugin; import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.Path; import org.eclipse.debug.core.ILaunchConfiguration; import org.eclipse.jdt.core.IClasspathContainer; import org.eclipse.jdt.core.IClasspathEntry; import org.eclipse.jdt.core.IJavaProject; import org.eclipse.jdt.core.IPackageFragmentRoot; import org.eclipse.jdt.core.JavaCore; import org.eclipse.jdt.core.JavaModelException; import org.eclipse.jdt.launching.IRuntimeClasspathEntry; import org.eclipse.jdt.launching.JavaRuntime; import org.w3c.dom.Document; import org.w3c.dom.Element; /** * Class to inspect classpath of an Eclipse project. */ public class EclipseClasspath { protected List<String> srcDirs = new ArrayList<>(); protected List<String> classDirs = new ArrayList<>(); protected List<List<String>> inclusionLists = new ArrayList<>(); protected List<List<String>> exclusionLists = new ArrayList<>(); protected Map<String, String> variable2valueMap = new LinkedHashMap<>(); protected List<String> rawClassPathEntries = new ArrayList<>(); protected List<String> rawClassPathEntriesAbsolute = new ArrayList<>(); private IJavaProject project; private static Map<String, IClasspathContainer> userLibraryCache = new HashMap<>(); /** * Initialize object with classpath of given project. */ public EclipseClasspath(IJavaProject project) throws JavaModelException { this.project = project; handle(project.getRawClasspath()); } /** * Initialize object with runtime classpath of given launch configuration. * * @param project * project that contains given launch configuration conf * @param conf * launch configuration * @param bootstrap * if true only bootstrap entries are added, if false only non-bootstrap entries are added */ public EclipseClasspath(IJavaProject project, ILaunchConfiguration conf, boolean bootstrap) throws CoreException { this.project = project; // convert IRuntimeClasspathEntry to IClasspathEntry IRuntimeClasspathEntry[] runtimeEntries; // see AbstractJavaLaunchConfigurationDelegate runtimeEntries = JavaRuntime.computeUnresolvedRuntimeClasspath(conf); List<IClasspathEntry> classpathEntries = new ArrayList<>(runtimeEntries.length); for (int i = 0; i < runtimeEntries.length; i++) { IRuntimeClasspathEntry entry = runtimeEntries[i]; if (bootstrap && (entry.getClasspathProperty() == IRuntimeClasspathEntry.BOOTSTRAP_CLASSES) || !bootstrap && (entry.getClasspathProperty() != IRuntimeClasspathEntry.BOOTSTRAP_CLASSES)) { // NOTE: See AbstractJavaLaunchConfigurationDelegate.getBootpathExt() // for an alternate bootclasspath detection if (entry.getClass().getName().equals("org.eclipse.jdt.internal.launching.VariableClasspathEntry")) //$NON-NLS-1$ { IClasspathEntry e = convertVariableClasspathEntry(entry); if (e != null) { classpathEntries.add(e); } } else if (entry.getClass().getName() .equals("org.eclipse.jdt.internal.launching.DefaultProjectClasspathEntry")) //$NON-NLS-1$ { IClasspathEntry e = JavaCore.newProjectEntry(entry.getPath()); classpathEntries.add(e); } else if (entry.getClasspathEntry() != null) { classpathEntries.add(entry.getClasspathEntry()); } } else if (bootstrap && entry.toString().startsWith(JavaRuntime.JRE_CONTAINER)) { classpathEntries.add(entry.getClasspathEntry()); } else if (bootstrap && entry.toString().startsWith(JavaCore.USER_LIBRARY_CONTAINER_ID)) { classpathEntries.add(entry.getClasspathEntry()); } } IClasspathEntry[] entries = classpathEntries.toArray(new IClasspathEntry[classpathEntries.size()]); handle(entries); } private void handle(IClasspathEntry[] entries) throws JavaModelException { for (int i = 0; i < entries.length; i++) { handleSources(entries[i]); handleVariables(entries[i]); handleJars(entries[i]); handleLibraries(entries[i]); handleProjects(entries[i]); } } private void handleSources(IClasspathEntry entry) throws JavaModelException { String projectRoot = ExportUtil.getProjectRoot(project); String defaultClassDir = project.getOutputLocation().toString(); String defaultClassDirAbsolute = ExportUtil.resolve(project.getOutputLocation()); if (entry.getContentKind() == IPackageFragmentRoot.K_SOURCE && entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) { // found source path IPath srcDirPath = entry.getPath(); IPath classDirPath = entry.getOutputLocation(); String srcDir = handleLinkedResource(srcDirPath); ExportUtil.removeProjectRoot((srcDirPath != null) ? srcDirPath.toString() : projectRoot, project.getProject()); String classDir = ExportUtil.removeProjectRoot( (classDirPath != null) ? classDirPath.toString() : defaultClassDir, project.getProject()); srcDirs.add(srcDir); classDirs.add(classDir); String classDirAbsolute = (classDirPath != null) ? ExportUtil.resolve(classDirPath) : defaultClassDirAbsolute; rawClassPathEntries.add(classDir); rawClassPathEntriesAbsolute.add(classDirAbsolute); IPath[] inclusions = entry.getInclusionPatterns(); List<String> inclusionList = new ArrayList<>(); for (int j = 0; j < inclusions.length; j++) { if (inclusions[j] != null) { inclusionList.add(ExportUtil.removeProjectRoot(inclusions[j].toString(), project.getProject())); } } inclusionLists.add(inclusionList); IPath[] exclusions = entry.getExclusionPatterns(); List<String> exclusionList = new ArrayList<>(); for (int j = 0; j < exclusions.length; j++) { if (exclusions[j] != null) { exclusionList.add(ExportUtil.removeProjectRoot(exclusions[j].toString(), project.getProject())); } } exclusionLists.add(exclusionList); } } /** * Check if given source path is a linked resource. Add values to {@link #variable2valueMap} accordingly. * * @param srcDirPath * source dir as IPath * @return source directory with reference, e.g. ${MYPATH}/src, if it is no link, orginal source dir is returned */ private String handleLinkedResource(IPath srcDirPath) { String projectRoot = ExportUtil.getProjectRoot(project); String srcDir = ExportUtil.removeProjectRoot((srcDirPath != null) ? srcDirPath.toString() : projectRoot, project.getProject()); if (srcDirPath == null) { return srcDir; } IFile file; try { file = ResourcesPlugin.getWorkspace().getRoot().getFile(srcDirPath); } catch (IllegalArgumentException e) { return srcDir; } if (file.isLinked()) { String pathVariable = file.getRawLocation().segment(0).toString(); URI pathVariableValue = file.getWorkspace().getPathVariableManager().getURIValue(pathVariable); if (pathVariableValue != null) { // path variable was used String pathVariableExtension = file.getRawLocation().removeFirstSegments(1).toString(); // Bug 192726 String relativePath = ExportUtil.getRelativePath(pathVariableValue.toString(), projectRoot); variable2valueMap.put(pathVariable + ".pathvariable", relativePath); //$NON-NLS-1$ variable2valueMap.put(srcDir + ".link", //$NON-NLS-1$ "${" + pathVariable + ".pathvariable}/" + pathVariableExtension); //$NON-NLS-1$ //$NON-NLS-2$ } else { String relativePath = ExportUtil .getRelativePath(file.getLocation() + IAntCoreConstants.EMPTY_STRING, projectRoot); variable2valueMap.put(srcDir + ".link", relativePath); //$NON-NLS-1$ } srcDir = "${" + srcDir + ".link}"; //$NON-NLS-1$ //$NON-NLS-2$ } return srcDir; } private void handleJars(IClasspathEntry entry) { if (entry.getContentKind() == IPackageFragmentRoot.K_BINARY && entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) { String jarFile = entry.getPath().toString(); StringBuffer jarFileBuffer = new StringBuffer(); StringBuffer jarFileAbsoluteBuffer = new StringBuffer(); String jarFileAbsolute = ExportUtil.resolve(entry.getPath()); if (jarFileAbsolute == null) { jarFileAbsolute = jarFile; // jarFile was already absolute if (handleSubProjectClassesDirectory(jarFile, jarFileBuffer, jarFileAbsoluteBuffer)) { jarFile = jarFileBuffer.toString(); jarFileAbsolute = jarFileAbsoluteBuffer.toString(); } } String jarFileOld = jarFile; jarFile = ExportUtil.removeProjectRoot(jarFile, project.getProject()); if (jarFile.equals(jarFileOld)) { if (handleSubProjectClassesDirectory(jarFile, jarFileBuffer, jarFileAbsoluteBuffer)) { jarFile = jarFileBuffer.toString(); jarFileAbsolute = jarFileAbsoluteBuffer.toString(); } } rawClassPathEntries.add(jarFile); rawClassPathEntriesAbsolute.add(jarFileAbsolute); } } /** * Checks if file is a class directory of a subproject and fills string buffers with resolved values. * * @param file * file to check * @param jarFile * filled with file location with variable reference ${project.location}, which is also added to variable2valueMap * @param jarFileAbsolute * filled with absolute file location * @return true if file is a classes directory */ private boolean handleSubProjectClassesDirectory(String file, StringBuffer jarFile, StringBuffer jarFileAbsolute) { // class directory of a subproject? if (file != null && file.indexOf('/') == 0) { int i = file.indexOf('/', 1); i = (i != -1) ? i : file.length(); String subproject = file.substring(1, i); IJavaProject javaproject = ExportUtil.getJavaProjectByName(subproject); if (javaproject != null) { jarFile.setLength(0); jarFileAbsolute.setLength(0); String location = javaproject.getProject().getName() + ".location"; //$NON-NLS-1$ jarFileAbsolute.append(ExportUtil.replaceProjectRoot(file, javaproject.getProject(), ExportUtil.getProjectRoot(javaproject))); jarFile.append( ExportUtil.replaceProjectRoot(file, javaproject.getProject(), "${" + location + "}")); //$NON-NLS-1$ //$NON-NLS-2$ String projectRoot = ExportUtil.getProjectRoot(project); String relativePath = ExportUtil.getRelativePath(ExportUtil.getProjectRoot(javaproject), projectRoot); variable2valueMap.put(location, relativePath); return true; } } return false; } private void handleVariables(IClasspathEntry entry) { if (entry.getContentKind() == IPackageFragmentRoot.K_SOURCE && entry.getEntryKind() == IClasspathEntry.CPE_VARIABLE) { // found variable String e = entry.getPath().toString(); int index = e.indexOf('/'); if (index == -1) { index = e.indexOf('\\'); } String variable = e; String path = IAntCoreConstants.EMPTY_STRING; if (index != -1) { variable = e.substring(0, index); path = e.substring(index); } IPath value = JavaCore.getClasspathVariable(variable); if (value != null) { String projectRoot = ExportUtil.getProjectRoot(project); String relativePath = ExportUtil.getRelativePath(value.toString(), projectRoot); variable2valueMap.put(variable, relativePath); } else if (variable2valueMap.get(variable) == null) { // only add empty value, if variable is new variable2valueMap.put(variable, IAntCoreConstants.EMPTY_STRING); } rawClassPathEntriesAbsolute.add(value + path); rawClassPathEntries.add("${" + variable + "}" + path); //$NON-NLS-1$ //$NON-NLS-2$ } } private void handleLibraries(IClasspathEntry entry) throws JavaModelException { if (entry.getContentKind() == IPackageFragmentRoot.K_SOURCE && entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) { // found library IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), project); if (container == null) { // jar missing (project not compile clean) return; } String jar = entry.getPath().toString(); String refName; if (jar.startsWith(JavaRuntime.JRE_CONTAINER)) { // JRE System Library refName = "${jre.container}"; //$NON-NLS-1$ } else if (jar.startsWith(JavaCore.USER_LIBRARY_CONTAINER_ID)) { // User Library String libraryName = container.getDescription(); refName = "${" + libraryName + ".userclasspath}"; //$NON-NLS-1$ //$NON-NLS-2$ if (container.getKind() == IClasspathContainer.K_SYSTEM) { refName = "${" + libraryName + ".bootclasspath}"; //$NON-NLS-1$ //$NON-NLS-2$ } } else { // Library dependencies: e.g. Plug-in Dependencies String libraryName = container.getDescription(); refName = "${" + libraryName + ".libraryclasspath}"; //$NON-NLS-1$ //$NON-NLS-2$ } userLibraryCache.put(refName, container); srcDirs.add(refName); classDirs.add(refName); rawClassPathEntries.add(refName); rawClassPathEntriesAbsolute.add(refName); inclusionLists.add(new ArrayList<String>()); exclusionLists.add(new ArrayList<String>()); } } private void handleProjects(IClasspathEntry entry) { if (entry.getContentKind() == IPackageFragmentRoot.K_SOURCE && entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) { // found required project on build path String subProjectRoot = entry.getPath().toString(); IJavaProject subProject = ExportUtil.getJavaProject(subProjectRoot); if (subProject == null) { // project was not loaded in workspace AntUIPlugin.log("project is not loaded in workspace: " + subProjectRoot, null); //$NON-NLS-1$ return; } // only add an indicator that this is a project reference String classpathRef = "${" + subProject.getProject().getName() + ".classpath}"; //$NON-NLS-1$ //$NON-NLS-2$ srcDirs.add(classpathRef); classDirs.add(classpathRef); rawClassPathEntries.add(classpathRef); rawClassPathEntriesAbsolute.add(classpathRef); inclusionLists.add(new ArrayList<String>()); exclusionLists.add(new ArrayList<String>()); } } /** * Get runtime classpath items for given project separated with path separator. */ public static String getClasspath(IJavaProject project) throws CoreException { List<String> items = getClasspathList(project); return ExportUtil.toString(items, File.pathSeparator); } /** * Get runtime classpath items for given project. */ public static List<String> getClasspathList(IJavaProject project) throws CoreException { String[] classpath = JavaRuntime.computeDefaultRuntimeClassPath(project); return Arrays.asList(classpath); } /** * Check if given string is a reference. */ public static boolean isReference(String s) { return isProjectReference(s) || isUserLibraryReference(s) || isUserSystemLibraryReference(s) || isLibraryReference(s) || isJreReference(s); // NOTE: A linked resource is no reference } /** * Check if given string is a project reference. */ public static boolean isProjectReference(String s) { return s.startsWith("${") && s.endsWith(".classpath}"); //$NON-NLS-1$ //$NON-NLS-2$ } /** * Resolves given project reference to a project. * * @return <code>null</code> if project is not resolvable */ public static IJavaProject resolveProjectReference(String s) { String name = ExportUtil.removePrefixAndSuffix(s, "${", ".classpath}"); //$NON-NLS-1$ //$NON-NLS-2$ return ExportUtil.getJavaProjectByName(name); } /** * Check if given string is a user library reference. */ public static boolean isUserLibraryReference(String s) { return s.startsWith("${") && s.endsWith(".userclasspath}"); //$NON-NLS-1$ //$NON-NLS-2$ } /** * Check if given string is a user system library reference. This library is added to the compiler boot classpath. */ public static boolean isUserSystemLibraryReference(String s) { return s.startsWith("${") && s.endsWith(".bootclasspath}"); //$NON-NLS-1$ //$NON-NLS-2$ } /** * Check if given string is a library reference. e.g. Plug-in dependencies are library references. * */ public static boolean isLibraryReference(String s) { return s.startsWith("${") && s.endsWith(".libraryclasspath}"); //$NON-NLS-1$ //$NON-NLS-2$ } /** * Check if given string is a JRE reference. */ public static boolean isJreReference(String s) { return s.equals("${jre.container}"); //$NON-NLS-1$ } /** * Resolves given user (system) library or plugin reference to its container. * * <p> * NOTE: The library can only be resolved if an EclipseClasspath object was created which had a reference to this library. The class holds an * internal cache to circumvent that UserLibraryManager is an internal class. * * @return null if library is not resolvable */ public static IClasspathContainer resolveUserLibraryReference(String s) { return userLibraryCache.get(s); } /** * Check if given string is a linked resource. * */ public static boolean isLinkedResource(String s) { return s.startsWith("${") && s.endsWith(".link}"); //$NON-NLS-1$ //$NON-NLS-2$ } /** * Get source folder name of a linked resource. * * @see #isLinkedResource(String) */ public static String getLinkedResourceName(String s) { return ExportUtil.removePrefixAndSuffix(s, "${", ".link}"); //$NON-NLS-1$ //$NON-NLS-2$ } /** * Resolves given linked resource to an absolute file location. */ public String resolveLinkedResource(String s) { String name = ExportUtil.removePrefixAndSuffix(s, "${", "}"); //$NON-NLS-1$ //$NON-NLS-2$ String value = variable2valueMap.get(name); String suffix = ".pathvariable}"; //$NON-NLS-1$ int i = value.indexOf(suffix); if (i != -1) { // path variable String pathVariable = value.substring(0, i + suffix.length() - 1); pathVariable = ExportUtil.removePrefix(pathVariable, "${"); //$NON-NLS-1$ return variable2valueMap.get(pathVariable) + value.substring(i + suffix.length()); } return value; } /** * Convert a VariableClasspathEntry to a IClasspathEntry. * * <p> * This is a workaround as entry.getClasspathEntry() returns null. */ private IClasspathEntry convertVariableClasspathEntry(IRuntimeClasspathEntry entry) { try { Document doc = ExportUtil.parseXmlString(entry.getMemento()); Element element = (Element) doc.getElementsByTagName("memento").item(0); //$NON-NLS-1$ String variableString = element.getAttribute("variableString"); //$NON-NLS-1$ ExportUtil.addVariable(variable2valueMap, variableString, ExportUtil.getProjectRoot(project)); // remove ${...} from string to be conform for handleVariables() variableString = ExportUtil.removePrefix(variableString, "${");//$NON-NLS-1$ int i = variableString.indexOf('}'); if (i != -1) { variableString = variableString.substring(0, i) + variableString.substring(i + 1); } IPath path = new Path(variableString); return JavaCore.newVariableEntry(path, null, null); } catch (Exception e) { AntUIPlugin.log(e); return null; } } }