plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/UpdateJavaBuildPathOperation.java - gerrit/jeetools/webtools.javaee - Git at Google

 /*******************************************************************************
  * 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);
 	}
 }
	/*******************************************************************************
	* 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);
	}
	}