| /******************************************************************************* |
| * Copyright (c) 2006 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 |
| * Matt Chapman - initial version |
| * Helen Hawkins - updated for new ajde interface (bug 148190) |
| *******************************************************************************/ |
| package org.eclipse.ajdt.internal.core.ajde; |
| |
| import java.io.File; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.Set; |
| import java.util.TreeMap; |
| |
| import org.aspectj.ajde.core.IOutputLocationManager; |
| import org.eclipse.ajdt.core.AJLog; |
| import org.eclipse.ajdt.core.AspectJCorePreferences; |
| import org.eclipse.core.resources.IContainer; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IWorkspaceRoot; |
| 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.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.internal.core.JavaModelManager; |
| import org.eclipse.jdt.internal.core.builder.State; |
| import org.eclipse.jdt.internal.core.builder.StringSet; |
| import org.eclipse.jdt.internal.core.util.Util; |
| |
| /** |
| * IOutputLocationManager implementation which uses the methods on IJavaProject |
| * to work out where the output should be sent. |
| * |
| * Important note about paths: |
| * Use Path.toOSString when describing a file on the filesystem |
| * Use Path.toPortableString when describing a resource in Eclipse's workspace. |
| */ |
| public class CoreOutputLocationManager implements IOutputLocationManager { |
| |
| /** |
| * |
| * @author Andrew Eisenberg |
| * @created Apr 9, 2009 |
| * use this to ensure that the longest strings are looked at first |
| * |
| * so, if src and src2 are both source folders, src2 will be |
| * examined first |
| */ |
| static class StringLengthComparator implements Comparator<String> { |
| public int compare(String s1, String s2) { |
| if (s1 == null) { |
| if (s2 == null) { |
| return 0; |
| } |
| return -1; |
| } |
| if (s2 == null) { |
| return 1; |
| } |
| int len1 = s1.length(); |
| int len2 = s2.length(); |
| if (len1 > len2) { // a larger string should come first |
| return -1; |
| } else if (len1 == len2) { |
| // then compare by text: |
| return s1.compareTo(s2); |
| } else { |
| return 1; |
| } |
| } |
| |
| } |
| |
| private static final StringLengthComparator comparator = new StringLengthComparator(); |
| |
| private final IProject project; |
| private final IJavaProject jProject; |
| |
| // if there is more than one output directory then the default output |
| // location to use is recorded in the 'defaultOutput' field |
| private File defaultOutput; |
| |
| private Map<String, File> srcFolderToOutput = new TreeMap<String, File>(comparator); |
| |
| private Map<File, IProject> binFolderToProject; |
| |
| // maps files in the file system to IFolders in the workspace |
| // this keeps track of output locations |
| private final Map<String, IContainer> fileSystemPathToIContainer = new TreeMap<String, IContainer>(comparator); |
| |
| private List<File> allOutputFolders = new ArrayList<File>(); |
| |
| // maps file system location to a path within the eclipse workspace |
| // needs to take into account linked sources, where the actual |
| // file system location may be different from the workspace location |
| private Map<String, String> allSourceFolders; |
| |
| private boolean outputIsRoot; |
| // if there is only one output directory then this is recorded in the |
| // 'commonOutputDir' field. |
| private File commonOutputDir; |
| private IWorkspaceRoot workspaceRoot; |
| |
| // Gather all of the files that are touched by this compilation |
| // and use it to determine which files need to have their |
| // Relationship maps updated. |
| private Set<File> compiledSourceFiles; |
| |
| private FileURICache fileCache; |
| |
| public CoreOutputLocationManager(IProject project, FileURICache fileCache) { |
| this.project = project; |
| this.fileCache = fileCache; |
| this.workspaceRoot = ResourcesPlugin.getWorkspace().getRoot(); |
| jProject = JavaCore.create(project); |
| initSourceFolders(); |
| if (!isUsingSeparateOutputFolders(jProject)) { |
| // using the same output directory therefore record this one |
| setCommonOutputDir(); |
| allOutputFolders.add(commonOutputDir); |
| |
| if (commonOutputDir != null) { |
| try { |
| if (outputIsRoot) { |
| fileSystemPathToIContainer.put(commonOutputDir.getAbsolutePath(), |
| project); |
| } else { |
| fileSystemPathToIContainer.put(commonOutputDir.getAbsolutePath(), |
| workspaceRoot.getFolder(jProject.getOutputLocation())); |
| } |
| } catch (JavaModelException e) { |
| } |
| } |
| } else { |
| // need to record all possible output directories |
| init(); |
| } |
| |
| } |
| |
| public void buildStarting() { |
| compiledSourceFiles = new HashSet<File>(); |
| } |
| |
| public void buildComplete() { |
| compiledSourceFiles = null; |
| } |
| |
| /** |
| * initialize the source folder locations only |
| */ |
| private void initSourceFolders() { |
| allSourceFolders = new TreeMap<String, String>(comparator); |
| try { |
| IClasspathEntry[] cpe = jProject.getRawClasspath(); |
| for (int i = 0; i < cpe.length; i++) { |
| if (cpe[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) { |
| IPath path = cpe[i].getPath(); |
| IPath rawPath; |
| path = path.removeFirstSegments(1).makeRelative(); |
| if (path.segmentCount() > 0) { |
| IFolder folder = project.getFolder(path); |
| rawPath = folder.getLocation(); |
| } else { |
| rawPath = project.getLocation(); |
| } |
| allSourceFolders.put(rawPath.toOSString(), path.toPortableString()); |
| } |
| } |
| } catch (JavaModelException e) { |
| } |
| } |
| |
| /** |
| * Calculate all the output locations |
| */ |
| private void init() { |
| outputIsRoot = false; |
| String inpathOutFolderString = getInpathOutputFolder(); |
| boolean isUsingNonDefaultInpathOutfolder = inpathOutFolderString != null; |
| |
| try { |
| IPath outputLocationPath = jProject.getOutputLocation(); |
| defaultOutput = workspacePathToFile(outputLocationPath); |
| allOutputFolders.add(defaultOutput); |
| |
| |
| fileSystemPathToIContainer.put(defaultOutput.getAbsolutePath(), |
| project.getFullPath().equals(outputLocationPath) |
| ? (IContainer) project |
| : (IContainer) workspaceRoot.getFolder(outputLocationPath)); |
| |
| |
| IClasspathEntry[] cpe = jProject.getRawClasspath(); |
| |
| |
| // store separate output folders in map |
| for (int i = 0; i < cpe.length; i++) { |
| if (cpe[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) { |
| IPath output = cpe[i].getOutputLocation(); |
| if (output != null) { |
| IPath path = cpe[i].getPath(); |
| |
| String srcFolder = path.removeFirstSegments(1).toPortableString(); |
| if (path.segmentCount() == 1) { // output folder is project |
| srcFolder = path.toPortableString(); |
| } |
| File out = workspacePathToFile(output); |
| srcFolderToOutput.put(srcFolder, out); |
| if (!allOutputFolders.contains(out)) { |
| allOutputFolders.add(out); |
| |
| fileSystemPathToIContainer.put(out.getAbsolutePath(), |
| workspaceRoot.getFolder(output)); |
| } |
| if (outputIsRoot) { |
| // bug 153682: if the project is the source folder |
| // then this output folder will always apply |
| defaultOutput = out; |
| } |
| } |
| } |
| } |
| |
| // check to see if on inpath and need a special out folder for it. |
| if (isUsingNonDefaultInpathOutfolder) { |
| // first add the inpath out folder to the list of out folders |
| IPath inpathOutFolderPath = new Path(inpathOutFolderString); |
| IFolder inpathOutFolder = workspaceRoot.getFolder(inpathOutFolderPath); |
| File out = inpathOutFolder.getLocation().toFile(); |
| fileSystemPathToIContainer.put(out.getAbsolutePath(), |
| workspaceRoot.getFolder(inpathOutFolderPath)); |
| |
| // now map everything coming from the in path to this out folder |
| for (int i = 0; i < cpe.length; i++) { |
| if (AspectJCorePreferences.isOnInpath(cpe[i])) { |
| // now must resolve the entry so that all jars contained in it |
| // are mapped. |
| List<IClasspathEntry> containerEntries = AspectJCorePreferences.resolveClasspath(cpe[i], project); |
| for (IClasspathEntry containerEntry : containerEntries) { |
| IPath path = containerEntry.getPath(); |
| File f = workspacePathToFile(path); |
| if (f != null && f.exists()) { |
| // use full path |
| String srcFolder = new Path(f.getPath()).toPortableString(); |
| srcFolderToOutput.put(srcFolder,out); |
| } else { |
| // outfolder does not exist |
| // probably because Project has been renamed |
| // and inpath output location has not been updated. |
| // this is handled with a message to the user |
| } |
| } |
| } |
| } |
| } |
| } catch (JavaModelException e) { |
| } |
| } |
| |
| private boolean isComputingXmlFile() { |
| StackTraceElement[] stacktrace = Thread.currentThread().getStackTrace(); |
| int max = stacktrace.length; |
| if (max > 6) max = 6; |
| for (int i=(max-1);i>0;i--) { |
| String s = stacktrace[i].toString(); |
| // org.aspectj.ajdt.internal.core.builder.AjBuildManager.writeOutxmlFile(AjBuildManager.java:659) probably at i==4 |
| if (s.startsWith("org.aspectj.ajdt.internal.core.builder.AjBuildManager.writeOutxmlFile")) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| public File getOutputLocationForClass(File compilationUnit) { |
| // remember that this file has been asked for |
| // presumably it is being recompiled |
| if (Util.isJavaLikeFileName(compilationUnit.getName()) && !isComputingXmlFile()) { |
| if (compiledSourceFiles == null) { |
| // pr540403 |
| AJLog.log(AJLog.BUILDER,"Unexpectedly buildStarted() has not been called yet, unable to record: "+compilationUnit.getName()); |
| } else { |
| compiledSourceFiles.add(compilationUnit); |
| } |
| } |
| |
| return getOutputLocationForResource(compilationUnit); |
| } |
| |
| public File getOutputLocationForResource(File resource) { |
| if (!isUsingSeparateOutputFolders(jProject)) { |
| return commonOutputDir; |
| } |
| if (resource == null || resource.toString() == null) { |
| return defaultOutput; |
| } |
| |
| // due to linked files, there may be multiple IResource relating to a single File |
| IResource[] resources; |
| IFile[] files = fileCache.findFilesForURI(resource.toURI()); |
| if (files != null && files.length > 0) { |
| resources = new IResource[files.length]; |
| for (int i = 0; i < files.length; i++) { |
| resources[i] = files[i]; |
| } |
| } else { |
| IContainer[] containers = fileCache.findContainersForURI(resource.toURI()); |
| if (containers != null && containers.length > 0) { |
| resources = new IResource[containers.length]; |
| for (int i = 0; i < containers.length; i++) { |
| resources[i] = containers[i]; |
| } |
| } else { |
| resources = null; |
| } |
| } |
| |
| String pathStr = null; |
| if (resources != null && resources.length > 0) { |
| // check if there is another version of the file |
| // that is linked to this project |
| // since the IResources are returned in an |
| // arbitrary order, doesn't matter which one we choose |
| IProject project = jProject.getProject(); |
| for (int i = 0; i < resources.length; i++) { |
| if (resources[i].getProject().equals(project)) { |
| pathStr = resources[i].getFullPath().removeFirstSegments(1).toPortableString(); |
| break; |
| } |
| } |
| if (pathStr == null) { |
| // this is from a location outside of the current project, |
| // use full path |
| pathStr = resources[0].getLocation().toPortableString(); |
| } |
| } |
| |
| if (pathStr == null) { |
| // if still null at this point, then assume that we have a fully qualified path |
| // coming from the inpath going to the inpath out folder |
| pathStr = new Path(resource.getPath()).toPortableString(); |
| } |
| |
| for (String src : srcFolderToOutput.keySet()) { |
| if (pathStr.startsWith(src)) { |
| File out = srcFolderToOutput.get(src); |
| return out; |
| } |
| } |
| |
| // couldn't find anything |
| return defaultOutput; |
| } |
| |
| /** |
| * @return true if there is more than one output directory being used by |
| * this project and false otherwise |
| */ |
| private boolean isUsingSeparateOutputFolders(IJavaProject jp) { |
| if (getInpathOutputFolder() != null) { |
| return true; |
| } |
| try { |
| IClasspathEntry[] cpe = jp.getRawClasspath(); |
| for (int i = 0; i < cpe.length; i++) { |
| if (cpe[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) { |
| if (cpe[i].getOutputLocation() != null) { |
| return true; |
| } |
| } |
| } |
| } catch (JavaModelException e) { |
| } |
| return false; |
| } |
| |
| /** |
| * Record the 'common output directory', namely the one where all the output |
| * goes |
| */ |
| private void setCommonOutputDir() { |
| IJavaProject jProject = JavaCore.create(project); |
| IPath workspaceRelativeOutputPath; |
| try { |
| workspaceRelativeOutputPath = jProject.getOutputLocation(); |
| } catch (JavaModelException e) { |
| commonOutputDir = project.getLocation().toFile(); |
| outputIsRoot = true; |
| return; |
| } |
| if (workspaceRelativeOutputPath.segmentCount() == 1) { |
| commonOutputDir = jProject.getResource().getLocation().toFile(); |
| outputIsRoot = true; |
| return; |
| } |
| IFolder out = ResourcesPlugin.getWorkspace().getRoot().getFolder(workspaceRelativeOutputPath); |
| commonOutputDir = out.getLocation().toFile(); |
| } |
| |
| private File workspacePathToFile(IPath path) { |
| if (path.segmentCount() == 1) { |
| // bug 153682: getFolder fails when the path is a project |
| IResource res = workspaceRoot.findMember(path); |
| outputIsRoot = true; |
| return res.getLocation().toFile(); |
| } |
| |
| IPath outPath; |
| IResource out; |
| String fileExtension = path.getFileExtension(); |
| if (fileExtension != null) { |
| // assume a file |
| out = workspaceRoot.getFile(path); |
| } else { |
| out = workspaceRoot.getFolder(path); |
| } |
| if (out.getProject().exists()) { |
| outPath = out.getLocation(); |
| } else { |
| // maybe this is a fully qualified path |
| outPath = path; |
| } |
| |
| if (outPath != null) { |
| return outPath.toFile(); |
| } else { |
| return null; |
| } |
| } |
| |
| |
| /** |
| * return all output directories used by this project |
| */ |
| public List<File> getAllOutputLocations() { |
| return allOutputFolders; |
| } |
| |
| public String getInpathOutputFolder() { |
| String inpathOutFolder = AspectJCorePreferences.getProjectInpathOutFolder(project); |
| // assume that the folder is valid... |
| // null means that the default out folder is used |
| return inpathOutFolder; |
| } |
| |
| |
| /** |
| * Called when build is completed. Respond with all source files compiled |
| * for this build |
| * @return all source files compiled for this build |
| */ |
| public File[] getCompiledSourceFiles() { |
| return compiledSourceFiles == null ? new File[0] : compiledSourceFiles.toArray(new File[compiledSourceFiles.size()]); |
| } |
| |
| |
| /** |
| * If there's only one output directory return this one, otherwise return |
| * the one marked as default |
| */ |
| public File getDefaultOutputLocation() { |
| if (!isUsingSeparateOutputFolders(jProject)) { |
| return commonOutputDir; |
| } else { |
| return defaultOutput; |
| } |
| } |
| |
| public String getSourceFolderForFile(File sourceFile) { |
| String sourceFilePath = sourceFile.getAbsolutePath(); |
| for (Entry<String, String> sourceFolderMapping : allSourceFolders.entrySet()) { |
| if (sourceFilePath.startsWith(sourceFolderMapping.getKey())) { |
| return sourceFolderMapping.getValue(); |
| } |
| } |
| |
| // might be a linked folder in a source folder |
| IFile[] files = fileCache.findFilesForURI(sourceFile.toURI()); |
| try { |
| IPackageFragmentRoot[] roots = jProject.getPackageFragmentRoots(); |
| for (IPackageFragmentRoot root : roots) { |
| if (!root.isReadOnly()) { |
| IContainer container = (IContainer) root.getResource(); |
| for (IFile file : files) { |
| if (container.getFullPath().isPrefixOf(file.getFullPath())) { |
| return allSourceFolders.get(container.getLocation().toOSString()); |
| } |
| } |
| } |
| } |
| } catch (JavaModelException e) { |
| } |
| |
| |
| return null; |
| } |
| |
| public void reportFileRemove(String outFileStr, int fileType) { |
| for (Entry<String, IContainer> entry : fileSystemPathToIContainer.entrySet()) { |
| String outFolderStr = entry.getKey(); |
| if (outFileStr.startsWith(outFolderStr)) { |
| IContainer outFolder = entry.getValue(); |
| IFile outFile = outFolder.getFile(new Path(outFileStr.substring(outFolderStr.length()))); |
| try { |
| outFile.refreshLocal(IResource.DEPTH_ZERO, null); |
| return; |
| } catch (CoreException e) { |
| } |
| } |
| } |
| |
| } |
| |
| |
| public Map<File,String> getInpathMap() { |
| return Collections.emptyMap(); |
| } |
| |
| |
| /** |
| * This method must do two things. First, it performs a refreshLocal on |
| * the newly changed file. Then it marks the file and all of its parent |
| * folders as derived (up to, but not including the output folder itself). |
| * Folders are marked as derived only if the output folder is not the same |
| * as the source folder. |
| */ |
| public void reportFileWrite(String outFileStr, int fileType) { |
| try { |
| outer: |
| for (Entry<String, IContainer> entry : fileSystemPathToIContainer.entrySet()) { |
| String outFolderStr = entry.getKey(); |
| if (outFileStr.startsWith(outFolderStr)) { |
| IContainer outFolder = entry.getValue(); |
| IFile outFile = outFolder.getFile(new Path(outFileStr.substring(outFolderStr.length()))); |
| |
| outFile.refreshLocal(IResource.DEPTH_ZERO, null); |
| |
| if (outFile.exists()) { |
| |
| // if this is a resource whose source folder and out folder are the same, |
| // do not mark as derived |
| boolean outputIsSourceFolder = isOutFolderASourceFolder(outFolder); |
| if (! isResourceInSourceFolder(outFile, outputIsSourceFolder)) { |
| outFile.setDerived(true, null); |
| } |
| |
| // only do this if output is not a source folder |
| if (!outputIsSourceFolder) { |
| IContainer parent = outFile.getParent(); |
| inner: |
| while (!parent.equals(outFolder) ) { |
| if (!parent.isDerived()) { |
| parent.setDerived(true, null); |
| } else { |
| // no need to continnue |
| // assume that all folders are derived all the way up |
| break inner; |
| } |
| parent = parent.getParent(); |
| if (parent == null) { |
| // shouldn't happen |
| break inner; |
| } |
| } |
| } |
| break outer; |
| } |
| } |
| |
| } |
| } catch (CoreException e) { |
| } |
| } |
| |
| private boolean isResourceInSourceFolder(IFile outFile, |
| boolean outputIsSourceFolder) { |
| return !(outFile.getFileExtension() != null && outFile.getFileExtension().equals("class")) |
| && outputIsSourceFolder; |
| } |
| |
| private boolean isOutFolderASourceFolder(IContainer outFolder) { |
| return outputIsRoot || srcFolderToOutput.containsKey(outFolder.getFullPath().removeFirstSegments(1).makeRelative().toPortableString()); |
| } |
| |
| /** |
| * Return the Java project that has outputFolder as an output location, or null if it is |
| * not recognized. |
| * |
| * This method can return null if outputFolder is not found |
| * in any declaring project |
| * |
| */ |
| protected IProject findDeclaringProject(File outputFolder) { |
| if (binFolderToProject == null) { |
| initDeclaringProjectsMap(); |
| } |
| return binFolderToProject.get(outputFolder); |
| } |
| |
| |
| /** |
| * the field binFolderToProject must be refreshed before each build |
| * because we are not sure if any bin folders in downstream projects |
| * have changed. |
| * |
| * See bug 270335 |
| */ |
| protected void zapBinFolderToProjectMap() { |
| binFolderToProject = null; |
| } |
| |
| /** |
| * Initialize the binFolderToProject map so that the map contains |
| * java.io.File -> IProject where the file is an output location |
| * and the project is where this output location is defined |
| */ |
| private void initDeclaringProjectsMap() { |
| |
| AJLog.logStart("OutputLocationManager: binary folder to declaring project map creation: " + project); |
| binFolderToProject = new HashMap<File, IProject>(); |
| IJavaProject jp = jProject; |
| try { |
| mapProject(jp); |
| } catch (JavaModelException e) { |
| } |
| AJLog.logEnd(AJLog.BUILDER_CLASSPATH, "OutputLocationManager: binary folder to declaring project map creation: " + project); |
| } |
| |
| private void mapProject(IJavaProject jp) throws JavaModelException { |
| IClasspathEntry[] cpes = jp.getRawClasspath(); |
| for (int i = 0; i < cpes.length; i++) { |
| if (cpes[i].isExported() || |
| cpes[i].getEntryKind() == IClasspathEntry.CPE_SOURCE || |
| jp == jProject) { |
| handleClassPathEntry(jp, cpes[i]); |
| } |
| } |
| } |
| |
| private void handleClassPathEntry(IJavaProject jp, IClasspathEntry cpe) throws JavaModelException { |
| switch (cpe.getEntryKind()) { |
| case IClasspathEntry.CPE_CONTAINER: |
| IClasspathContainer container = |
| JavaCore.getClasspathContainer(cpe.getPath(), jp); |
| if (container != null && container.getKind() != IClasspathContainer.K_DEFAULT_SYSTEM) { |
| IClasspathEntry[] cpes = container.getClasspathEntries(); |
| for (int i = 0; i < cpes.length; i++) { |
| handleClassPathEntry(jp, cpes[i]); |
| } |
| } |
| break; |
| case IClasspathEntry.CPE_LIBRARY: |
| File libFile = pathToFile(cpe.getPath()); |
| if (libFile.isDirectory()) { // ignore jar files |
| if (libFile != null && !binFolderToProject.containsKey(libFile)) { |
| binFolderToProject.put(libFile, jp.getProject()); |
| } |
| } |
| break; |
| case IClasspathEntry.CPE_PROJECT: |
| IJavaProject jpClasspath = pathToProject(cpe.getPath()); |
| if (jpClasspath != null) { |
| mapProject(jpClasspath); |
| } |
| break; |
| |
| case IClasspathEntry.CPE_SOURCE: |
| File outFile = pathToFile(cpe.getOutputLocation() == null ? jp.getOutputLocation() : cpe.getOutputLocation()); |
| if (outFile != null && ! binFolderToProject.containsKey(outFile)) { |
| binFolderToProject.put(outFile, jp.getProject()); |
| } |
| break; |
| case IClasspathEntry.CPE_VARIABLE: |
| IClasspathEntry cpeResolved = JavaCore.getResolvedClasspathEntry(cpe); |
| if (cpeResolved != null) { |
| handleClassPathEntry(jp, cpeResolved); |
| } |
| break; |
| } |
| } |
| |
| private IJavaProject pathToProject(IPath path) { |
| if (path != null && path.segmentCount() > 0) { |
| IProject p = ResourcesPlugin.getWorkspace().getRoot().getProject(path.segments()[0]); |
| return JavaCore.create(p); |
| } else { |
| return null; |
| } |
| } |
| |
| private File pathToFile(IPath path) { |
| // Bug 279497 if path is only one segment, then assume it is a project |
| |
| IPath locPath = path.segmentCount() > 1 ? |
| ResourcesPlugin.getWorkspace().getRoot().getFolder(path).getLocation() : |
| ResourcesPlugin.getWorkspace().getRoot().getProject(path.makeRelative().toOSString()).getLocation(); |
| File f; |
| if (locPath != null) { |
| f = locPath.toFile(); |
| } else { |
| f = path.toFile(); |
| } |
| return f; |
| } |
| |
| /** |
| * Aim of this callback from the compiler is to ask Eclipse if it knows which project has the |
| * supplied directory as an output folder, and if that can be determined then look at the |
| * last structural build time of that project and any structurally changed types since that |
| * build time. If it doesn't look like anything has changed since the supplied buildtime then |
| * we assume that means nothing changed in the directory and so do not need to check the time |
| * stamp of each file within it. |
| * |
| * This method does nothing more than a rudimentary analysis - if there are changes then it does |
| * not currently attempt to determine if they are interesting (ie. whether they are changes to |
| * types that the compiler asking the question depends upon). |
| */ |
| public int discoverChangesSince(File dir, long buildtime) { |
| IProject project = findDeclaringProject(dir); |
| try { |
| if (project!=null) { |
| Object s = JavaModelManager.getJavaModelManager().getLastBuiltState(project, null); |
| if (s != null && s instanceof State) { |
| State state = (State) s; |
| long dependeeTime = getLastStructuralBuildTime(state); |
| if (dependeeTime < buildtime) { |
| StringSet changes = getStructurallyChangedTypes(state); |
| // this test isn't quite right... but it basically works |
| if (changes==null || changes.elementSize==0) { |
| return 1; // no changes at all (doesnt determine whether they are of interest) |
| } |
| } |
| } |
| } |
| } catch (Exception e) { |
| } |
| return 0; // DONTKNOW - this will cause the caller to do the .class modtime tests |
| } |
| |
| |
| private static long getLastStructuralBuildTime(State state) |
| throws Exception { |
| if (lastStructuralBuildTimeField == null) { |
| lastStructuralBuildTimeField = State.class.getDeclaredField("lastStructuralBuildTime"); |
| lastStructuralBuildTimeField.setAccessible(true); |
| } |
| return lastStructuralBuildTimeField.getLong(state); |
| } |
| |
| private static StringSet getStructurallyChangedTypes(State state) |
| throws Exception { |
| if (structurallyChangedTypesField == null) { |
| structurallyChangedTypesField = State.class.getDeclaredField("structurallyChangedTypes"); |
| structurallyChangedTypesField.setAccessible(true); |
| } |
| return (StringSet)structurallyChangedTypesField.get(state); |
| } |
| |
| // Cached for performance reasons |
| private static java.lang.reflect.Field lastStructuralBuildTimeField = null; |
| private static java.lang.reflect.Field structurallyChangedTypesField = null; |
| |
| } |
