/*******************************************************************************
* Copyright (c) 2003, 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
*******************************************************************************/
package org.eclipse.jst.j2ee.internal.common.operations;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jst.j2ee.application.internal.operations.ClassPathSelection;
import org.eclipse.jst.j2ee.application.internal.operations.ClasspathElement;
import org.eclipse.wst.common.frameworks.internal.DoNotUseMeThisWillBeDeletedPost15;
import org.eclipse.wst.common.frameworks.internal.enablement.nonui.WFTWrappedException;
import org.eclipse.wst.common.frameworks.internal.operations.IHeadlessRunnableWithProgress;
/**
* {@link DoNotUseMeThisWillBeDeletedPost15}
*
* @deprecated This should no longer be necessary because of the new EAR & Web Lib classpath
* containers
*/
public class UpdateJavaBuildPathOperation implements IHeadlessRunnableWithProgress {
protected IJavaProject javaProject;
protected ClassPathSelection classPathSelection;
// All the Java build path entries created by the classpath selection
protected Set allClasspathEntries;
protected List allUnselectedClasspathEntries;
/**
* UpdateJavaBuildPathOperation constructor comment.
*/
public UpdateJavaBuildPathOperation(IJavaProject aJavaProject, ClassPathSelection aClassPathSelection) {
super();
javaProject = aJavaProject;
classPathSelection = aClassPathSelection;
allClasspathEntries = new HashSet();
IClasspathEntry[] classpathEntry = aClassPathSelection.getClasspathEntriesForSelected();
if (classpathEntry != null)
allClasspathEntries.addAll(Arrays.asList(classpathEntry));
}
/**
* UpdateJavaBuildPathOperation constructor comment.
*/
public UpdateJavaBuildPathOperation(IJavaProject aJavaProject, ClassPathSelection selected, ClassPathSelection unselected) {
super();
javaProject = aJavaProject;
classPathSelection = selected;
allClasspathEntries = new HashSet();
if (selected != null && !selected.getClasspathElements().isEmpty())
allClasspathEntries.addAll(Arrays.asList(selected.getClasspathEntriesForSelected()));
allUnselectedClasspathEntries = new ArrayList();
if (unselected != null && !unselected.getClasspathElements().isEmpty())
allUnselectedClasspathEntries.addAll(unselected.getClasspathElements());
}
public UpdateJavaBuildPathOperation(IJavaProject aJavaProject, ClassPathSelection selected, List unselected) {
super();
javaProject = aJavaProject;
classPathSelection = selected;
allClasspathEntries = new HashSet();
if (selected != null && !selected.getClasspathElements().isEmpty())
allClasspathEntries.addAll(Arrays.asList(selected.getClasspathEntriesForSelected()));
allUnselectedClasspathEntries = new ArrayList();
if (unselected != null && !unselected.isEmpty())
allUnselectedClasspathEntries.addAll(unselected);
}
protected void ensureClasspathEntryIsExported(List cp, IClasspathEntry entry) {
if (entry.isExported())
return;
int index = getIndex(cp, entry);
IClasspathEntry newEntry = null;
switch (entry.getEntryKind()) {
case IClasspathEntry.CPE_PROJECT :
newEntry = JavaCore.newProjectEntry(entry.getPath(), true);
break;
case IClasspathEntry.CPE_LIBRARY :
newEntry = JavaCore.newLibraryEntry(entry.getPath(), entry.getSourceAttachmentPath(), entry.getSourceAttachmentRootPath(), true);
break;
case IClasspathEntry.CPE_VARIABLE :
newEntry = JavaCore.newVariableEntry(entry.getPath(), entry.getSourceAttachmentPath(), entry.getSourceAttachmentRootPath());
}
cp.set(index, newEntry);
}
protected IClasspathEntry ensureElementInList(List cp, ClasspathElement element, IClasspathEntry predecessor) {
IClasspathEntry addedEntry = null;
// The element might have multiple entries in the case of
// the imported_classes.jar file
IClasspathEntry[] cpEntries = element.newClasspathEntries();
if (cpEntries == null || cpEntries.length == 0)
// indicates an invalid entry
return null;
int predecessorPos = predecessor == null ? -1 : getIndex(cp, predecessor);
addedEntry = cpEntries[0];
// Ensure that the first item is in the list, and follows
// the predecessor if specified; preserve existing items in
// the case of source attachments
int pos = getIndex(cp, addedEntry);
if (pos == -1) {
if (predecessorPos == -1)
cp.add(addedEntry);
else
cp.add(predecessorPos + 1, addedEntry);
} else {
addedEntry = (IClasspathEntry) cp.get(pos);
if (pos < predecessorPos) {
cp.remove(addedEntry);
cp.add(predecessorPos, addedEntry);
}
}
ensureClasspathEntryIsExported(cp, addedEntry);
// Remove and add so we can ensure the proper order; this
// is the case of the imported_classes.jar; we always want it
// directly after the project
for (int i = 1; i < cpEntries.length; i++) {
int index = getIndex(cp, cpEntries[i]);
if (index != -1) {
addedEntry = (IClasspathEntry) cp.get(index);
cp.remove(index);
} else
addedEntry = cpEntries[i];
pos = getIndex(cp, cpEntries[0]);
cp.add(pos + 1, addedEntry);
}
return addedEntry;
}
protected int getIndex(List cp, IClasspathEntry entry) {
for (int i = 0; i < cp.size(); i++) {
IClasspathEntry elmt = (IClasspathEntry) cp.get(i);
if (elmt.getPath().equals(entry.getPath()))
return i;
}
return -1;
}
protected void ensureElementNotInList(List cp, ClasspathElement element) {
IClasspathEntry[] cpEntries = element.newClasspathEntries();
if (cpEntries == null || cpEntries.length == 0)
return;
for (int i = 0; i < cpEntries.length; i++) {
if (allClasspathEntries.contains(cpEntries[i]))
// This may be included indirectly by a transitive dependency
continue;
int index = getIndex(cp, cpEntries[i]);
if (index != -1)
cp.remove(index);
}
}
protected void ensureRemoveElementInList(List cp, ClasspathElement element) {
IClasspathEntry[] cpEntries = element.newClasspathEntries();
if (cpEntries == null || cpEntries.length == 0)
return;
for (int i = 0; i < cpEntries.length; i++) {
if (cp.contains(cpEntries[i])) {
int index = getIndex(cp, cpEntries[i]);
if (index != -1)
cp.remove(index);
}
}
}
/**
* Runs this operation. Progress should be reported to the given progress monitor. This method
* is usually invoked by an <code>IRunnableContext</code>'s<code>run</code> method, which
* supplies the progress monitor. A request to cancel the operation should be honored and
* acknowledged by throwing <code>InterruptedException</code>.
*
* @param monitor
* the progress monitor to use to display progress and receive requests for
* cancelation
* @exception InvocationTargetException
* if the run method must propagate a checked exception, it should wrap it inside
* an <code>InvocationTargetException</code>; runtime exceptions are
* automatically wrapped in an <code>InvocationTargetException</code> by the
* calling context
* @exception InterruptedException
* if the operation detects a request to cancel, using
* <code>IProgressMonitor.isCanceled()</code>, it should exit by throwing
* <code>InterruptedException</code>
*
* @see IRunnableContext#run
*/
public void run(org.eclipse.core.runtime.IProgressMonitor monitor) throws java.lang.reflect.InvocationTargetException, InterruptedException {
try {
String[] prevRequiredProjects = javaProject.getRequiredProjectNames();
List cp = new ArrayList(Arrays.asList(javaProject.getRawClasspath()));
List classpathElements = classPathSelection.getClasspathElements();
IClasspathEntry predecessor = null;
IClasspathEntry result = null;
for (int i = 0; i < classpathElements.size(); i++) {
ClasspathElement element = (ClasspathElement) classpathElements.get(i);
if (element.isSelected()) {
result = ensureElementInList(cp, element, predecessor);
if (result != null)
predecessor = result;
} else
ensureElementNotInList(cp, element);
}
filterUnselectedEntries(cp);
IClasspathEntry[] newCp = ((IClasspathEntry[]) cp.toArray(new IClasspathEntry[cp.size()]));
javaProject.setRawClasspath(newCp, monitor);
updateRequiredProjects(javaProject, prevRequiredProjects, new SubProgressMonitor(monitor, 1));
} catch (Exception ex) {
throw new WFTWrappedException(ex);
}
}
private void filterUnselectedEntries(List cp) {
if (allUnselectedClasspathEntries != null) {
for (int i = 0; i < allUnselectedClasspathEntries.size(); i++) {
ClasspathElement element = (ClasspathElement) allUnselectedClasspathEntries.get(i);
ensureRemoveElementInList(cp, element);
}
}
}
protected void updateRequiredProjects(IJavaProject jproject, String[] prevRequiredProjects, IProgressMonitor monitor) throws CoreException {
String[] newRequiredProjects = jproject.getRequiredProjectNames();
ArrayList prevEntries = new ArrayList(Arrays.asList(prevRequiredProjects));
ArrayList newEntries = new ArrayList(Arrays.asList(newRequiredProjects));
IProject proj = jproject.getProject();
IProjectDescription projDesc = proj.getDescription();
ArrayList newRefs = new ArrayList();
IProject[] referencedProjects = projDesc.getReferencedProjects();
for (int i = 0; i < referencedProjects.length; i++) {
String curr = referencedProjects[i].getName();
if (newEntries.remove(curr) || !prevEntries.contains(curr)) {
newRefs.add(referencedProjects[i]);
}
}
IWorkspaceRoot root = proj.getWorkspace().getRoot();
for (int i = 0; i < newEntries.size(); i++) {
String curr = (String) newEntries.get(i);
newRefs.add(root.getProject(curr));
}
projDesc.setReferencedProjects((IProject[]) newRefs.toArray(new IProject[newRefs.size()]));
proj.setDescription(projDesc, monitor);
}
}