IJavaProject's classpath.
*
* @see IJavaProject
*/
public class SetClasspathOperation extends JavaModelOperation {
IClasspathEntry[] oldResolvedPath, newResolvedPath;
IClasspathEntry[] newRawPath;
boolean canChangeResources;
boolean classpathWasSaved;
boolean needCycleCheck;
boolean needValidation;
boolean needSave;
IPath newOutputLocation;
JavaProject project;
boolean identicalRoots;
public static final IClasspathEntry[] ReuseClasspath = new IClasspathEntry[0];
public static final IClasspathEntry[] UpdateClasspath = new IClasspathEntry[0];
// if reusing output location, then also reuse clean flag
public static final IPath ReuseOutputLocation = new Path("Reuse Existing Output Location"); //$NON-NLS-1$
/**
* When executed, this operation sets the classpath of the given project.
*/
public SetClasspathOperation(
JavaProject project,
IClasspathEntry[] oldResolvedPath,
IClasspathEntry[] newRawPath,
IPath newOutputLocation,
boolean canChangeResource,
boolean needValidation,
boolean needSave) {
super(new IJavaElement[] { project });
this.oldResolvedPath = oldResolvedPath;
this.newRawPath = newRawPath;
this.newOutputLocation = newOutputLocation;
this.canChangeResources = canChangeResource;
this.needValidation = needValidation;
this.needSave = needSave;
this.project = project;
}
/**
* Adds deltas for the given roots, with the specified change flag,
* and closes the root. Helper method for #setClasspath
*/
protected void addClasspathDeltas(
IPackageFragmentRoot[] roots,
int flag,
JavaElementDelta delta) {
for (int i = 0; i < roots.length; i++) {
IPackageFragmentRoot root = roots[i];
delta.changed(root, flag);
if ((flag & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) != 0
|| (flag & IJavaElementDelta.F_SOURCEATTACHED) != 0
|| (flag & IJavaElementDelta.F_SOURCEDETACHED) != 0){
try {
root.close();
} catch (JavaModelException e) {
}
// force detach source on jar package fragment roots (source will be lazily computed when needed)
((PackageFragmentRoot) root).setSourceAttachmentProperty(null);// loose info - will be recomputed
}
}
}
/**
* Returns the index of the item in the list if the given list contains the specified entry. If the list does
* not contain the entry, -1 is returned.
* A helper method for #setClasspath
*/
protected int classpathContains(
IClasspathEntry[] list,
IClasspathEntry entry) {
IPath[] exclusionPatterns = entry.getExclusionPatterns();
nextEntry: for (int i = 0; i < list.length; i++) {
IClasspathEntry other = list[i];
if (other.getContentKind() == entry.getContentKind()
&& other.getEntryKind() == entry.getEntryKind()
&& other.isExported() == entry.isExported()
&& other.getPath().equals(entry.getPath())) {
// check custom outputs
IPath entryOutput = entry.getOutputLocation();
IPath otherOutput = other.getOutputLocation();
if (entryOutput == null) {
if (otherOutput != null)
continue;
} else {
if (!entryOutput.equals(otherOutput))
continue;
}
// check exclusion patterns
IPath[] otherExcludes = other.getExclusionPatterns();
if (exclusionPatterns != otherExcludes) {
int excludeLength = exclusionPatterns.length;
if (otherExcludes.length != excludeLength)
continue;
for (int j = 0; j < excludeLength; j++) {
// compare toStrings instead of IPaths
// since IPath.equals is specified to ignore trailing separators
if (!exclusionPatterns[j].toString().equals(otherExcludes[j].toString()))
continue nextEntry;
}
}
return i;
}
}
return -1;
}
/**
* Recursively adds all subfolders of folder to the given collection.
*/
protected void collectAllSubfolders(IFolder folder, ArrayList collection) throws JavaModelException {
try {
IResource[] members= folder.members();
for (int i = 0, max = members.length; i < max; i++) {
IResource r= members[i];
if (r.getType() == IResource.FOLDER) {
collection.add(r);
collectAllSubfolders((IFolder)r, collection);
}
}
} catch (CoreException e) {
throw new JavaModelException(e);
}
}
/**
* Returns a collection of package fragments that have been added/removed
* as the result of changing the output location to/from the given
* location. The collection is empty if no package fragments are
* affected.
*/
// protected ArrayList determineAffectedPackageFragments(IPath location) throws JavaModelException {
// ArrayList fragments = new ArrayList();
// JavaProject project =getProject();
//
// // see if this will cause any package fragments to be affected
// IWorkspace workspace = ResourcesPlugin.getWorkspace();
// IResource resource = null;
// if (location != null) {
// resource = workspace.getRoot().findMember(location);
// }
// if (resource != null && resource.getType() == IResource.FOLDER) {
// IFolder folder = (IFolder) resource;
// // only changes if it actually existed
// IClasspathEntry[] classpath = project.getExpandedClasspath(true);
// for (int i = 0; i < classpath.length; i++) {
// IClasspathEntry entry = classpath[i];
// IPath path = classpath[i].getPath();
// if (entry.getEntryKind() != IClasspathEntry.CPE_PROJECT && path.isPrefixOf(location) && !path.equals(location)) {
// IPackageFragmentRoot[] roots = project.computePackageFragmentRoots(classpath[i]);
// IPackageFragmentRoot root = roots[0];
// // now the output location becomes a package fragment - along with any subfolders
// ArrayList folders = new ArrayList();
// folders.add(folder);
// collectAllSubfolders(folder, folders);
// Iterator elements = folders.iterator();
// int segments = path.segmentCount();
// while (elements.hasNext()) {
// IFolder f = (IFolder) elements.next();
// IPath relativePath = f.getFullPath().removeFirstSegments(segments);
// String name = relativePath.toOSString();
// name = name.replace(File.pathSeparatorChar, '.');
// if (name.endsWith(".")) { //$NON-NLS-1$
// name = name.substring(0, name.length() - 1);
// }
// IPackageFragment pkg = root.getPackageFragment(name);
// fragments.add(pkg);
// }
// }
// }
// }
// return fragments;
// }
/**
* Sets the classpath of the pre-specified project.
*/
protected void executeOperation() throws JavaModelException {
// project reference updated - may throw an exception if unable to write .project file
updateProjectReferencesIfNecessary();
// classpath file updated - may throw an exception if unable to write .classpath file
saveClasspathIfNecessary();
// perform classpath and output location updates, if exception occurs in classpath update,
// make sure the output location is updated before surfacing the exception (in case the output
// location update also throws an exception, give priority to the classpath update one).
JavaModelException originalException = null;
try {
if (this.newRawPath == UpdateClasspath) this.newRawPath = project.getRawClasspath();
if (this.newRawPath != ReuseClasspath){
updateClasspath();
project.updatePackageFragmentRoots();
JavaModelManager.getJavaModelManager().getDeltaProcessor().addForRefresh(project);
}
} catch(JavaModelException e){
originalException = e;
throw e;
} finally { // if traversed by an exception we still need to update the output location when necessary
try {
if (this.newOutputLocation != ReuseOutputLocation) updateOutputLocation();
} catch(JavaModelException e){
if (originalException != null) throw originalException;
throw e;
} finally {
// ensures the project is getting rebuilt if only variable is modified
if (!this.identicalRoots && this.canChangeResources) {
try {
this.project.getProject().touch(this.progressMonitor);
} catch (CoreException e) {
if (JavaModelManager.CP_RESOLVE_VERBOSE){
Util.verbose("CPContainer INIT - FAILED to touch project: "+ this.project.getElementName(), System.err); //$NON-NLS-1$
e.printStackTrace();
}
}
}
}
}
done();
}
/**
* Generates the delta of removed/added/reordered roots.
* Use three deltas in case the same root is removed/added/reordered (for
* instance, if it is changed from K_SOURCE to K_BINARY or vice versa)
*/
protected void generateClasspathChangeDeltas() {
JavaModelManager manager = JavaModelManager.getJavaModelManager();
boolean needToUpdateDependents = false;
JavaElementDelta delta = new JavaElementDelta(getJavaModel());
boolean hasDelta = false;
if (this.classpathWasSaved) {
delta.changed(this.project, IJavaElementDelta.F_CLASSPATH_CHANGED);
hasDelta = true;
}
int oldLength = oldResolvedPath.length;
int newLength = newResolvedPath.length;
// final IndexManager indexManager = manager.getIndexManager();
Map oldRoots = null;
IPackageFragmentRoot[] roots = null;
if (project.isOpen()) {
try {
roots = project.getPackageFragmentRoots();
} catch (JavaModelException e) {
// ignore
}
} else {
Map allRemovedRoots ;
if ((allRemovedRoots = manager.getDeltaProcessor().removedRoots) != null) {
roots = (IPackageFragmentRoot[]) allRemovedRoots.get(project);
}
}
if (roots != null) {
oldRoots = new HashMap();
for (int i = 0; i < roots.length; i++) {
IPackageFragmentRoot root = roots[i];
oldRoots.put(root.getPath(), root);
}
}
for (int i = 0; i < oldLength; i++) {
int index = classpathContains(newResolvedPath, oldResolvedPath[i]);
if (index == -1) {
// do not notify remote project changes
if (oldResolvedPath[i].getEntryKind() == IClasspathEntry.CPE_PROJECT){
needToUpdateDependents = true;
this.needCycleCheck = true;
continue;
}
IPackageFragmentRoot[] pkgFragmentRoots = null;
if (oldRoots != null) {
IPackageFragmentRoot oldRoot = (IPackageFragmentRoot) oldRoots.get(oldResolvedPath[i].getPath());
if (oldRoot != null) { // use old root if any (could be none if entry wasn't bound)
pkgFragmentRoots = new IPackageFragmentRoot[] { oldRoot };
}
}
if (pkgFragmentRoots == null) {
try {
ObjectVector accumulatedRoots = new ObjectVector();
HashSet rootIDs = new HashSet(5);
rootIDs.add(project.rootID());
project.computePackageFragmentRoots(
oldResolvedPath[i],
accumulatedRoots,
rootIDs,
true, // inside original project
false, // don't check existency
false); // don't retrieve exported roots
pkgFragmentRoots = new IPackageFragmentRoot[accumulatedRoots.size()];
accumulatedRoots.copyInto(pkgFragmentRoots);
} catch (JavaModelException e) {
pkgFragmentRoots = new IPackageFragmentRoot[] {};
}
}
addClasspathDeltas(pkgFragmentRoots, IJavaElementDelta.F_REMOVED_FROM_CLASSPATH, delta);
int changeKind = oldResolvedPath[i].getEntryKind();
needToUpdateDependents |= (changeKind == IClasspathEntry.CPE_SOURCE) || oldResolvedPath[i].isExported();
// Remove the .java files from the index for a source folder
// For a lib folder or a .jar file, remove the corresponding index if not shared.
// if (indexManager != null) {
// IClasspathEntry oldEntry = oldResolvedPath[i];
// final IPath path = oldEntry.getPath();
// switch (changeKind) {
// case IClasspathEntry.CPE_SOURCE:
// final char[][] inclusionPatterns = null; //((ClasspathEntry)oldEntry).fullInclusionPatternChars();
// final char[][] exclusionPatterns = ((ClasspathEntry)oldEntry).fullExclusionPatternChars();
// postAction(new IPostAction() {
// public String getID() {
// return path.toString();
// }
// public void run() /* throws JavaModelException */ {
// indexManager.removeSourceFolderFromIndex(project, path, inclusionPatterns, exclusionPatterns);
// }
// },
// REMOVEALL_APPEND);
// break;
// case IClasspathEntry.CPE_LIBRARY:
// final DeltaProcessingState deltaState = manager.deltaState;
// postAction(new IPostAction() {
// public String getID() {
// return path.toString();
// }
// public void run() /* throws JavaModelException */ {
// if (deltaState.otherRoots.get(path) == null) { // if root was not shared
// indexManager.discardJobs(path.toString());
// indexManager.removeIndex(path);
// // TODO (kent) we could just remove the in-memory index and have the indexing check for timestamps
// }
// }
// },
// REMOVEALL_APPEND);
// break;
// }
// }
hasDelta = true;
} else {
// do not notify remote project changes
if (oldResolvedPath[i].getEntryKind() == IClasspathEntry.CPE_PROJECT){
this.needCycleCheck |= (oldResolvedPath[i].isExported() != newResolvedPath[index].isExported());
continue;
}
needToUpdateDependents |= (oldResolvedPath[i].isExported() != newResolvedPath[index].isExported());
if (index != i) { //reordering of the classpath
addClasspathDeltas(
project.computePackageFragmentRoots(oldResolvedPath[i]),
IJavaElementDelta.F_REORDER,
delta);
int changeKind = oldResolvedPath[i].getEntryKind();
needToUpdateDependents |= (changeKind == IClasspathEntry.CPE_SOURCE);
hasDelta = true;
}
// check source attachment
IPath newSourcePath = newResolvedPath[index].getSourceAttachmentPath();
int sourceAttachmentFlags =
this.getSourceAttachmentDeltaFlag(
oldResolvedPath[i].getSourceAttachmentPath(),
newSourcePath);
IPath oldRootPath = oldResolvedPath[i].getSourceAttachmentRootPath();
IPath newRootPath = newResolvedPath[index].getSourceAttachmentRootPath();
int sourceAttachmentRootFlags = getSourceAttachmentDeltaFlag(oldRootPath, newRootPath);
int flags = sourceAttachmentFlags | sourceAttachmentRootFlags;
if (flags != 0) {
addClasspathDeltas(project.computePackageFragmentRoots(oldResolvedPath[i]), flags, delta);
hasDelta = true;
} else {
if (oldRootPath == null && newRootPath == null) {
// if source path is specified and no root path, it needs to be recomputed dynamically
// force detach source on jar package fragment roots (source will be lazily computed when needed)
IPackageFragmentRoot[] computedRoots = project.computePackageFragmentRoots(oldResolvedPath[i]);
for (int j = 0; j < computedRoots.length; j++) {
IPackageFragmentRoot root = computedRoots[j];
// force detach source on jar package fragment roots (source will be lazily computed when needed)
try {
root.close();
} catch (JavaModelException e) {
// ignore
}
((PackageFragmentRoot) root).setSourceAttachmentProperty(null);// loose info - will be recomputed
}
}
}
}
}
for (int i = 0; i < newLength; i++) {
int index = classpathContains(oldResolvedPath, newResolvedPath[i]);
if (index == -1) {
// do not notify remote project changes
if (newResolvedPath[i].getEntryKind() == IClasspathEntry.CPE_PROJECT){
needToUpdateDependents = true;
this.needCycleCheck = true;
continue;
}
addClasspathDeltas(
project.computePackageFragmentRoots(newResolvedPath[i]),
IJavaElementDelta.F_ADDED_TO_CLASSPATH,
delta);
int changeKind = newResolvedPath[i].getEntryKind();
// Request indexing
// if (indexManager != null) {
// switch (changeKind) {
// case IClasspathEntry.CPE_LIBRARY:
// boolean pathHasChanged = true;
// final IPath newPath = newResolvedPath[i].getPath();
// for (int j = 0; j < oldLength; j++) {
// IClasspathEntry oldEntry = oldResolvedPath[j];
// if (oldEntry.getPath().equals(newPath)) {
// pathHasChanged = false;
// break;
// }
// }
// if (pathHasChanged) {
// postAction(new IPostAction() {
// public String getID() {
// return newPath.toString();
// }
// public void run() /* throws JavaModelException */ {
// indexManager.indexLibrary(newPath, project.getProject());
// }
// },
// REMOVEALL_APPEND);
// }
// break;
// case IClasspathEntry.CPE_SOURCE:
// IClasspathEntry entry = newResolvedPath[i];
// final IPath path = entry.getPath();
// final char[][] inclusionPatterns = null; //((ClasspathEntry)entry).fullInclusionPatternChars();
// final char[][] exclusionPatterns = ((ClasspathEntry)entry).fullExclusionPatternChars();
// postAction(new IPostAction() {
// public String getID() {
// return path.toString();
// }
// public void run() /* throws JavaModelException */ {
// indexManager.indexSourceFolder(project, path, inclusionPatterns, exclusionPatterns);
// }
// },
// APPEND); // append so that a removeSourceFolder action is not removed
// break;
// }
// }
needToUpdateDependents |= (changeKind == IClasspathEntry.CPE_SOURCE) || newResolvedPath[i].isExported();
hasDelta = true;
} // classpath reordering has already been generated in previous loop
}
if (hasDelta) {
this.addDelta(delta);
} else {
this.identicalRoots = true;
}
if (needToUpdateDependents){
updateAffectedProjects(project.getProject().getFullPath());
}
}
protected void saveClasspathIfNecessary() throws JavaModelException {
if (!this.canChangeResources || !this.needSave) return;
IClasspathEntry[] classpathForSave;
if (this.newRawPath == ReuseClasspath || this.newRawPath == UpdateClasspath){
classpathForSave = project.getRawClasspath();
} else {
classpathForSave = this.newRawPath;
}
IPath outputLocationForSave;
if (this.newOutputLocation == ReuseOutputLocation){
outputLocationForSave = project.getOutputLocation();
} else {
outputLocationForSave = this.newOutputLocation;
}
// if read-only .classpath, then the classpath setting will never been performed completely
if (project.saveClasspath(classpathForSave, outputLocationForSave)) {
this.classpathWasSaved = true;
this.setAttribute(HAS_MODIFIED_RESOURCE_ATTR, TRUE);
}
}
protected JavaProject getProject() {
return ((JavaProject) getElementsToProcess()[0]);
}
/*
* Returns the source attachment flag for the delta between the 2 give source paths.
* Returns either F_SOURCEATTACHED, F_SOURCEDETACHED, F_SOURCEATTACHED | F_SOURCEDETACHED
* or 0 if there is no difference.
*/
private int getSourceAttachmentDeltaFlag(IPath oldPath, IPath newPath, IPath sourcePath) {
if (oldPath == null) {
if (newPath != null) {
return IJavaElementDelta.F_SOURCEATTACHED;
} else {
if (sourcePath != null) {
// if source path is specified and no root path, it needs to be recomputed dynamically
return IJavaElementDelta.F_SOURCEATTACHED | IJavaElementDelta.F_SOURCEDETACHED;
} else {
return 0;
}
}
} else if (newPath == null) {
return IJavaElementDelta.F_SOURCEDETACHED;
} else if (!oldPath.equals(newPath)) {
return IJavaElementDelta.F_SOURCEATTACHED | IJavaElementDelta.F_SOURCEDETACHED;
} else {
return 0;
}
}
/*
* Returns the source attachment flag for the delta between the 2 give source paths.
* Returns either F_SOURCEATTACHED, F_SOURCEDETACHED, F_SOURCEATTACHED | F_SOURCEDETACHED
* or 0 if there is no difference.
*/
private int getSourceAttachmentDeltaFlag(IPath oldPath, IPath newPath) {
if (oldPath == null) {
if (newPath != null) {
return IJavaElementDelta.F_SOURCEATTACHED;
} else {
return 0;
}
} else if (newPath == null) {
return IJavaElementDelta.F_SOURCEDETACHED;
} else if (!oldPath.equals(newPath)) {
return IJavaElementDelta.F_SOURCEATTACHED | IJavaElementDelta.F_SOURCEDETACHED;
} else {
return 0;
}
}
/**
* Returns true if this operation performs no resource modifications,
* otherwise false. Subclasses must override.
*/
public boolean isReadOnly() {
return !this.canChangeResources;
}
// protected void saveClasspathIfNecessary() throws JavaModelException {
//
// if (!this.canChangeResources || !this.needSave) return;
//
// IClasspathEntry[] classpathForSave;
// JavaProject project = getProject();
// if (this.newRawPath == ReuseClasspath || this.newRawPath == UpdateClasspath){
// classpathForSave = project.getRawClasspath();
// } else {
// classpathForSave = this.newRawPath;
// }
// IPath outputLocationForSave;
// if (this.newOutputLocation == ReuseOutputLocation){
// outputLocationForSave = project.getOutputLocation();
// } else {
// outputLocationForSave = this.newOutputLocation;
// }
// // if read-only .classpath, then the classpath setting will never been performed completely
// if (project.saveClasspath(classpathForSave, outputLocationForSave)) {
// this.setAttribute(HAS_MODIFIED_RESOURCE_ATTR, TRUE);
// }
// }
public String toString(){
StringBuffer buffer = new StringBuffer(20);
buffer.append("SetClasspathOperation\n"); //$NON-NLS-1$
buffer.append(" - classpath : "); //$NON-NLS-1$
if (this.newRawPath == ReuseClasspath){
buffer.append("This can cause changes in package fragments, in case either the * old or new output location folder are considered as a package fragment. */ protected void updateOutputLocation() throws JavaModelException { JavaProject project= ((JavaProject) getElementsToProcess()[0]); beginTask(Util.bind("classpath.settingOutputLocationProgress", project.getElementName()), 2); //$NON-NLS-1$ IPath oldLocation= project.getOutputLocation(); // see if this will cause any package fragments to be added boolean deltaToFire= false; JavaElementDelta delta = newJavaElementDelta(); // ArrayList added= determineAffectedPackageFragments(oldLocation); // Iterator iter = added.iterator(); // while (iter.hasNext()){ // IPackageFragment frag= (IPackageFragment)iter.next(); // ((IPackageFragmentRoot)frag.getParent()).close(); // if (!ProjectPrefUtil.isExcluded(frag)) { // delta.added(frag); // deltaToFire = true; // } // } // see if this will cause any package fragments to be removed // ArrayList removed= determineAffectedPackageFragments(this.newOutputLocation); // iter = removed.iterator(); // while (iter.hasNext()){ // IPackageFragment frag= (IPackageFragment)iter.next(); // ((IPackageFragmentRoot)frag.getParent()).close(); // if (!ProjectPrefUtil.isExcluded(frag)) { // delta.removed(frag); // deltaToFire = true; // } // } JavaModelManager.PerProjectInfo perProjectInfo = JavaModelManager.getJavaModelManager().getPerProjectInfoCheckExistence(project.getProject()); synchronized (perProjectInfo) { perProjectInfo.outputLocation = this.newOutputLocation; } if (deltaToFire) { addDelta(delta); } worked(1); } /** * Update projects references so that the build order is consistent with the classpath */ protected void updateProjectReferencesIfNecessary() throws JavaModelException { if (!this.canChangeResources) return; if (this.newRawPath == ReuseClasspath || this.newRawPath == UpdateClasspath) return; JavaProject jproject = getProject(); String[] oldRequired = jproject.projectPrerequisites(this.oldResolvedPath); if (this.newResolvedPath == null) { this.newResolvedPath = jproject.getResolvedClasspath(this.newRawPath, null, true, this.needValidation, null /*no reverse map*/); } String[] newRequired = jproject.projectPrerequisites(this.newResolvedPath); try { IProject project = jproject.getProject(); IProjectDescription description = project.getDescription(); IProject[] projectReferences = description.getReferencedProjects(); HashSet oldReferences = new HashSet(projectReferences.length); for (int i = 0; i < projectReferences.length; i++){ String projectName = projectReferences[i].getName(); oldReferences.add(projectName); } HashSet newReferences = (HashSet)oldReferences.clone(); for (int i = 0; i < oldRequired.length; i++){ String projectName = oldRequired[i]; newReferences.remove(projectName); } for (int i = 0; i < newRequired.length; i++){ String projectName = newRequired[i]; newReferences.add(projectName); } Iterator iter; int newSize = newReferences.size(); checkIdentity: { if (oldReferences.size() == newSize){ iter = newReferences.iterator(); while (iter.hasNext()){ if (!oldReferences.contains(iter.next())){ break checkIdentity; } } return; } } String[] requiredProjectNames = new String[newSize]; int index = 0; iter = newReferences.iterator(); while (iter.hasNext()){ requiredProjectNames[index++] = (String)iter.next(); } Util.sort(requiredProjectNames); // ensure that if changed, the order is consistent IProject[] requiredProjectArray = new IProject[newSize]; IWorkspaceRoot wksRoot = project.getWorkspace().getRoot(); for (int i = 0; i < newSize; i++){ requiredProjectArray[i] = wksRoot.getProject(requiredProjectNames[i]); } description.setReferencedProjects(requiredProjectArray); project.setDescription(description, this.progressMonitor); } catch(CoreException e){ throw new JavaModelException(e); } } public IJavaModelStatus verify() { IJavaModelStatus status = super.verify(); if (!status.isOK()) { return status; } if (needValidation) { IJavaProject project = (IJavaProject) getElementToProcess(); // retrieve classpath IClasspathEntry[] entries = this.newRawPath; if (entries == ReuseClasspath){ try { entries = project.getRawClasspath(); } catch (JavaModelException e) { return e.getJavaModelStatus(); } } // retrieve output location IPath outputLocation = this.newOutputLocation; if (outputLocation == ReuseOutputLocation){ try { outputLocation = project.getOutputLocation(); } catch (JavaModelException e) { return e.getJavaModelStatus(); } } // perform validation // return JavaConventions.validateClasspath( // project, // entries, // outputLocation); } return JavaModelStatus.VERIFIED_OK; } }