/*******************************************************************************
* Copyright (c) 2003, 2007 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.application.internal.operations;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
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.emf.common.util.URI;
import org.eclipse.jdt.core.IClasspathAttribute;
import org.eclipse.jdt.core.IClasspathContainer;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
import org.eclipse.jst.common.internal.modulecore.util.ArchiveManifest;
import org.eclipse.jst.common.jdt.internal.javalite.IJavaProjectLite;
import org.eclipse.jst.common.jdt.internal.javalite.JavaCoreLite;
import org.eclipse.jst.j2ee.classpathdep.ClasspathDependencyUtil;
import org.eclipse.jst.j2ee.classpathdep.IClasspathDependencyConstants;
import org.eclipse.jst.j2ee.classpathdep.IClasspathDependencyConstants.DependencyAttributeType;
import org.eclipse.jst.j2ee.commonarchivecore.internal.Archive;
import org.eclipse.jst.j2ee.commonarchivecore.internal.CommonArchiveResourceHandler;
import org.eclipse.jst.j2ee.commonarchivecore.internal.CommonarchiveFactory;
import org.eclipse.jst.j2ee.commonarchivecore.internal.Container;
import org.eclipse.jst.j2ee.commonarchivecore.internal.EARFile;
import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.ManifestException;
import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.OpenFailureException;
import org.eclipse.jst.j2ee.commonarchivecore.internal.strategy.LoadStrategy;
import org.eclipse.jst.j2ee.commonarchivecore.internal.strategy.ZipFileLoadStrategyImpl;
import org.eclipse.jst.j2ee.componentcore.J2EEModuleVirtualComponent;
import org.eclipse.jst.j2ee.internal.archive.operations.ComponentLoadStrategyImpl;
import org.eclipse.jst.j2ee.internal.archive.operations.EARComponentLoadStrategyImpl;
import org.eclipse.jst.j2ee.internal.modulecore.util.JEEManifestDiscerner;
import org.eclipse.jst.j2ee.internal.plugin.IJ2EEModuleConstants;
import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
import org.eclipse.jst.j2ee.model.IModelProvider;
import org.eclipse.jst.j2ee.model.ModelProviderManager;
import org.eclipse.jst.j2ee.project.EarUtilities;
import org.eclipse.jst.j2ee.project.JavaEEProjectUtilities;
import org.eclipse.jst.javaee.ejb.EJBJar;
import org.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.UnresolveableURIException;
import org.eclipse.wst.common.componentcore.internal.impl.ModuleURIUtil;
import org.eclipse.wst.common.componentcore.internal.resources.VirtualArchiveComponent;
import org.eclipse.wst.common.componentcore.internal.util.ComponentUtilities;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
public class ClassPathSelection {
protected Archive archive;
protected ArchiveManifest manifest;
protected IVirtualComponent component;
protected IProject earProject;
protected IVirtualComponent earComponent;
protected String earLibraryDirectory = null;
protected List classpathElements;
protected Map urisToElements;
protected boolean modified;
private String targetProjectName;
protected Map ejbToClientJARs = null;
protected Map clientToEJBJARs = null;
public static final int FILTER_EJB_SERVER_JARS = 0;
public static final int FILTER_EJB_CLIENT_JARS = 1;
public static final int FILTER_NONE = 2;
protected int filterLevel = 2;
protected static Comparator comparator = new Comparator() {
/**
* @see Comparator#compare(Object, Object)
*/
public int compare(Object o1, Object o2) {
int retVal = 0;
if (o1 instanceof Archive)
{
Archive a1 = (Archive) o1;
Archive a2 = (Archive) o2;
retVal = a1.getURI().compareTo(a2.getURI());
}
else if (o1 instanceof IVirtualReference)
{
IVirtualReference ref1 = (IVirtualReference) o1;
IVirtualReference ref2 = (IVirtualReference) o2;
retVal = ref1.getArchiveName().compareTo(ref2.getArchiveName());
}
else
{
retVal = o1.toString().compareTo(o2.toString());
}
return retVal;
}
};
public ClassPathSelection(Archive anArchive, String targetProjectName, EARFile earFile) {
super();
archive = anArchive;
this.targetProjectName = targetProjectName;
initializeEARProject(earFile);
initializeElements();
}
/**
* ClassPathSelection constructor comment.
*/
public ClassPathSelection(Archive anArchive, EARFile earFile) {
super();
archive = anArchive;
initializeEARProject(earFile);
initializeElements();
}
/**
* Creates without an EAR component.
*/
public ClassPathSelection(IVirtualComponent aComponent) {
super();
component = aComponent;
targetProjectName = aComponent.getProject().getName();
initializeElements();
}
/**
* ClassPathSelection constructor comment.
*/
public ClassPathSelection(IVirtualComponent aComponent, IVirtualComponent anEarComponent) {
this(aComponent);
earComponent = anEarComponent;
earProject = earComponent.getProject();
refreshEARLibraryDirectory();
initializeElements();
}
public ClassPathSelection(IVirtualComponent aComponent, IVirtualComponent anEarComponent, ArchiveManifest aManifest) {
this(aComponent);
earComponent = anEarComponent;
earProject = earComponent.getProject();
manifest = aManifest;
refreshEARLibraryDirectory();
initializeElements();
}
public ClassPathSelection(IVirtualComponent aComponent, ArchiveManifest aManifest) {
super();
component = aComponent;
targetProjectName = aComponent.getProject().getName();
manifest = aManifest;
initializeElements();
}
/**
* ClassPathSelection constructor comment.
*/
public ClassPathSelection() {
super();
}
protected ClasspathElement createElement(Archive referencingArchive, Archive referencedArchive, String cpEntry) {
ClasspathElement element = new ClasspathElement(referencingArchive);
element.setValid(true);
String uriString = referencedArchive.getURI();
URI uri = URI.createURI(uriString);
boolean hasAbsolutePath = uri.hasAbsolutePath();
if( hasAbsolutePath ){
uriString = uri.lastSegment();
}
//element.setText(referencedArchive.getURI());
element.setText(uriString);
element.setTargetArchive(referencedArchive);
element.setEarProject(earProject);
if( earComponent != null ){
IContainer earConentFolder = earComponent.getRootFolder().getUnderlyingFolder();
if( earConentFolder.getType() == IResource.FOLDER ){
element.setEarContentFolder( earConentFolder.getName());
}else {
element.setEarContentFolder( "" ); //$NON-NLS-1$
}
}
setProjectValues(element, referencedArchive);
if (cpEntry != null)
element.setValuesSelected(cpEntry);
setType(element, referencedArchive);
return element;
}
protected ClasspathElement createElement(IVirtualComponent referencingArchive, IVirtualReference referencedArchive, String cpEntry) {
IVirtualReference childProjectVirtualRef = null;
IVirtualReference[] hardRefs = earComponent.getReferences();
for( int i = 0; i < hardRefs.length; i++ ) {
if(hardRefs[i].getReferencedComponent().getProject().equals(referencingArchive.getProject())) {
childProjectVirtualRef = hardRefs[i];
break;
}
}
return createElement(childProjectVirtualRef, referencedArchive, cpEntry);
}
protected ClasspathElement createElement(IVirtualReference referencingArchive, IVirtualReference referencedArchive, String cpEntry) {
ClasspathElement element = new ClasspathElement(referencingArchive.getReferencedComponent());
element.setValid(true);
String uriString = JEEManifestDiscerner.calculateManifestRelativeRuntimePath(referencingArchive, referencedArchive).append((new Path(referencedArchive.getArchiveName())).lastSegment()).toString();
element.setText(uriString);
element.setTargetComponent(referencedArchive.getReferencedComponent());
element.setEarProject(earProject);
if( earComponent != null ){
IContainer earConentFolder = earComponent.getRootFolder().getUnderlyingFolder();
if( earConentFolder.getType() == IResource.FOLDER ){
element.setEarContentFolder( earConentFolder.getName());
}else {
element.setEarContentFolder( "" ); //$NON-NLS-1$
}
}
setProjectValues(element, referencedArchive);
if (cpEntry != null)
element.setValuesSelected(cpEntry);
setType(element, referencedArchive);
return element;
}
protected ClasspathElement createInvalidElement(String cpEntry) {
ClasspathElement element = new ClasspathElement(archive);
element.setValid(false);
element.setSelected(true);
element.setRelativeText(cpEntry);
element.setText(cpEntry);
element.setEarProject(earProject);
setInvalidProject(element);
return element;
}
public ClasspathElement createProjectElement(IProject project) {
ClasspathElement element = new ClasspathElement(project);
element.setValid(true);
element.setSelected(true);
element.setText(project.getName());
element.setProject(project);
addClasspathElement(element,element.getProjectName());
return element;
}
public ClasspathElement createProjectElement(IProject project, boolean existingEntry ) {
ClasspathElement element = new ClasspathElement(project);
element.setValid(true);
element.setSelected(existingEntry);
element.setText(project.getName());
element.setProject(project);
addClasspathElement(element,element.getProjectName());
return element;
}
public ClasspathElement createArchiveElement(URI uri, String name, String cpEntry) {
ClasspathElement element = new ClasspathElement(uri);
element.setValid(false);
element.setRelativeText(name);
if (cpEntry != null)
element.setValuesSelected(cpEntry);
element.setText(name);
element.setEarProject(earProject);
return element;
}
public void buildClasspathComponentDependencyMap(final IVirtualComponent comp, final Map pathToComp) {
if (comp != null && comp instanceof J2EEModuleVirtualComponent) {
J2EEModuleVirtualComponent j2eeComp = (J2EEModuleVirtualComponent) comp;
IVirtualReference[] cpRefs = j2eeComp.getJavaClasspathReferences();
for (int i = 0; i < cpRefs.length; i++) {
// only ../ mappings supported at this level
if (!cpRefs[i].getRuntimePath().equals(IClasspathDependencyConstants.RUNTIME_MAPPING_INTO_CONTAINER_PATH)) {
continue;
}
final IVirtualComponent referencedComponent = cpRefs[i].getReferencedComponent();
final IPath path = ClasspathDependencyUtil.getClasspathVirtualReferenceLocation(cpRefs[i]);
final IVirtualComponent existingComp = (IVirtualComponent) pathToComp.get(path);
if (existingComp != null) {
// replace with a temp VirtualArchiveComponent whose IProject is set to a new pseudo name that is
// the concatenation of all project contributions for that archive
if (existingComp instanceof VirtualArchiveComponent) {
final VirtualArchiveComponent oldComp = (VirtualArchiveComponent) existingComp;
final IVirtualComponent newComp = updateDisplayVirtualArchiveComponent(oldComp, cpRefs[i]);
pathToComp.put(path, newComp);
}
} else {
pathToComp.put(path, referencedComponent);
}
}
}
}
/**
* Create a new VirtualArchiveComponent (used only for display purposes) whose IProject is set to a dummy value whose
* name is a concatentation of the existing name and the name of the project associated with the new ref.
* This is used to represent the case where a single unique archive is referenced/contributed by multiple dependent projects.
* @deprecated
*/
public static VirtualArchiveComponent updateDisplayVirtualArchiveComponent(final VirtualArchiveComponent oldComp, final IVirtualReference newRef) {
final String newProjName = oldComp.getProject().getName() + " " + newRef.getReferencedComponent().getProject().getName(); //$NON-NLS-1$
final IProject newProj = ResourcesPlugin.getWorkspace().getRoot().getProject(newProjName);
final VirtualArchiveComponent newComponent = (VirtualArchiveComponent) ComponentCore.createArchiveComponent(newProj, oldComp.getName());
return newComponent;
}
/**
* Create a new VirtualArchiveComponent (used only for display purposes) whose IProject is set to a dummy value whose
* name is a concatentation of the existing name and the name of the project associated with the new ref.
* This is used to represent the case where a single unique archive is referenced/contributed by multiple dependent projects.
*/
public static IVirtualComponent updateVirtualArchiveComponentDisplay(final IVirtualComponent oldComp, final IVirtualReference newRef) {
final String newProjName = oldComp.getProject().getName() + " " + newRef.getReferencedComponent().getProject().getName(); //$NON-NLS-1$
final IProject newProj = ResourcesPlugin.getWorkspace().getRoot().getProject(newProjName);
return ComponentCore.createArchiveComponent(newProj, oldComp.getName());
}
public ClasspathElement[] createClasspathEntryElements(final IVirtualComponent comp, final IPath archiveRuntimePath, final IPath classFolderRuntimePath) throws CoreException {
final List elements = new ArrayList();
if (comp != null && comp.getProject().isAccessible()) {
final IProject project = comp.getProject();
if (project.hasNature(JavaCore.NATURE_ID)) {
final IJavaProjectLite javaProjectLite = JavaCoreLite.create(project);
final boolean isLegacyJ2EE = JavaEEProjectUtilities.isLegacyJ2EEComponent(comp);
final boolean isWebApp = JavaEEProjectUtilities.isDynamicWebProject(project);
final Map taggedEntries = ClasspathDependencyUtil.getRawComponentClasspathDependencies(javaProjectLite, DependencyAttributeType.CLASSPATH_COMPONENT_DEPENDENCY, isLegacyJ2EE);
Iterator i = taggedEntries.keySet().iterator();
while (i.hasNext()) {
final IClasspathEntry entry = (IClasspathEntry) i.next();
final IClasspathAttribute attrib = (IClasspathAttribute) taggedEntries.get(entry);
final boolean isClassFolder = ClasspathDependencyUtil.isClassFolderEntry(entry);
final IPath runtimePath = ClasspathDependencyUtil.getRuntimePath(attrib, isWebApp, isClassFolder);
if (runtimePath != null && ((isClassFolder && !runtimePath.equals(classFolderRuntimePath)) || (!isClassFolder && !runtimePath.equals(archiveRuntimePath)))) {
// if runtime path does not match target runtime path, skip
continue;
}
final ClasspathElement element = createClasspathElementForEntry(project, entry);
element.setSelected(true);
addClasspathElement(element, element.getArchiveURI().toString());
}
final List potentialEntries = ClasspathDependencyUtil.getPotentialComponentClasspathDependencies(javaProjectLite);
i = potentialEntries.iterator();
while (i.hasNext()) {
final IClasspathEntry entry = (IClasspathEntry) i.next();
if (isWebApp && classFolderRuntimePath.equals(IClasspathDependencyConstants.RUNTIME_MAPPING_INTO_COMPONENT_PATH) && ClasspathDependencyUtil.isClassFolderEntry(entry)) {
// don't display class folder dependencies for dynamic web projects on the non-web lib dependency page
continue;
}
final ClasspathElement element = createClasspathElementForEntry(project, entry);
element.setSelected(false);
addClasspathElement(element, element.getArchiveURI().toString());
}
}
}
return (ClasspathElement[]) elements.toArray(new ClasspathElement[elements.size()]);
}
private ClasspathElement createClasspathElementForEntry(final IProject project, final IClasspathEntry entry) {
final IPath entryPath = entry.getPath();
final URI archiveURI = URI.createURI(entryPath.toString());
final int kind = entry.getEntryKind();
String elementName = entryPath.toString();
if (kind == IClasspathEntry.CPE_CONTAINER) {
try {
final IClasspathContainer container = JavaCore.getClasspathContainer(entryPath, JavaCore.create(project));
if (container != null) {
elementName = container.getDescription();
}
} catch (CoreException ce) {
}
}
ClasspathElement element = createClasspathEntryElement(project, archiveURI, elementName, entry);
return element;
}
/**
* @param element
*/
private void setInvalidProject(ClasspathElement element) {
IProject earProj = element.getEarProject();
//IVirtualComponent[] component = ComponentUtilities.getComponent(earProj.getName());
IVirtualComponent refEarComponent = ComponentUtilities.getComponent(earProj.getName());
IVirtualReference[] references = J2EEProjectUtilities.getComponentReferences(refEarComponent);
String moduleName = element.getRelativeText();
if(moduleName != null) {
IVirtualComponent modComponent = null;
for (int cnt=0; cnt < references.length; cnt++)
{
if (moduleName.equals(references[cnt].getArchiveName()))
{
modComponent = references[cnt].getReferencedComponent();
}
}
if(modComponent != null) {
IProject mappedProject = modComponent.getProject();
element.setProject(mappedProject);
}
}
}
/**
* Insert the method's description here. Creation date: (8/22/2001 1:17:21 PM)
*
* @return java.util.List
*/
public java.util.List getClasspathElements() {
if(classpathElements == null)
classpathElements = new ArrayList();
return classpathElements;
}
public java.util.List getSelectedClasspathElements() {
ArrayList list = new ArrayList();
Iterator it = getClasspathElements().iterator();
while(it.hasNext()) {
ClasspathElement element = (ClasspathElement)it.next();
if( element.isSelected() ){
list.add(element);
}
}
return list;
}
/**
* Adapter method to convert the manifest class path entries which map to a project to a list of
* classpath entries for a java build path
*/
protected IClasspathEntry[] getClasspathEntries(boolean filterSelected) {
List result = new ArrayList();
IClasspathEntry[] array = null;
ClasspathElement element = null;
if(classpathElements != null) {
for (int i = 0; i < classpathElements.size(); i++) {
element = (ClasspathElement) classpathElements.get(i);
if (filterSelected && !element.isSelected())
continue;
array = ((ClasspathElement) classpathElements.get(i)).newClasspathEntries();
if (array == null)
continue;
for (int j = 0; j < array.length; j++) {
if (!result.contains(array[j]))
result.add(array[j]);
}
}
return (IClasspathEntry[]) result.toArray(new IClasspathEntry[result.size()]);
}
return null;
}
/**
* Adapter method to convert the manifest class path entries which map to a project to a list of
* classpath entries for a java build path
*/
public IClasspathEntry[] getClasspathEntriesForAll() {
return getClasspathEntries(false);
}
/**
* Adapter method to convert the manifest class path entries which map to a project to a list of
* classpath entries for a java build path
*/
public IClasspathEntry[] getClasspathEntriesForSelected() {
return getClasspathEntries(true);
}
protected EARFile getEARFile() {
if (archive == null)
return null;
Container parent = archive.getContainer();
if (parent != null && parent.isEARFile())
return (EARFile) parent;
return null;
}
protected static IProject getEARProject(Archive anArchive) {
Container c = anArchive.getContainer();
if (!c.isEARFile())
return null;
EARFile ear = (EARFile) c;
LoadStrategy loader = ear.getLoadStrategy();
if (!(loader instanceof EARComponentLoadStrategyImpl))
return null;
return ((EARComponentLoadStrategyImpl) loader).getComponent().getProject();
}
public Archive getArchive() {
return archive;
}
protected IProject getProject(Archive anArchive) {
IVirtualComponent comp = getComponent(anArchive);
if (comp != null) {
return comp.getProject();
}
return null;
}
protected IVirtualComponent getComponent(Archive anArchive) {
LoadStrategy loader = anArchive.getLoadStrategy();
if (loader instanceof ComponentLoadStrategyImpl)
return ((ComponentLoadStrategyImpl) loader).getComponent();
return null;
}
public String getText() {
return archive.getURI();
}
protected Archive getArchive(String uri, List archives) {
for (int i = 0; i < archives.size(); i++) {
Archive anArchive = (Archive) archives.get(i);
String archiveURIString = anArchive.getURI();
URI archiveURI = URI.createURI(archiveURIString);
boolean hasAbsolutePath = archiveURI.hasAbsolutePath();
if( hasAbsolutePath ){
archiveURIString = archiveURI.lastSegment();
}
if (archiveURIString.equals(uri))
return anArchive;
}
return null;
}
protected IVirtualReference getVirtualReference(String uri, List archives) {
for (int i = 0; i < archives.size(); i++) {
IVirtualReference anArchive = (IVirtualReference) archives.get(i);
IPath anArchivePath = anArchive.getRuntimePath().makeRelative();
String archiveURIString = anArchivePath.append(anArchive.getArchiveName()).toString();
if (archiveURIString.equals(uri))
return anArchive;
}
return null;
}
public static boolean isValidDependency(IVirtualComponent referencedJAR, IVirtualComponent referencingJAR) {
//No other modules should reference wars
if (JavaEEProjectUtilities.isDynamicWebComponent(referencedJAR))
return false;
if ( referencedJAR.getName().equals( referencingJAR.getName() ) )
return false;
//Clients can reference all but the WARs, which we've already covered
// above; WARs and EJB JARs
//can reference all but WARs, above, or ApplicationClients
return JavaEEProjectUtilities.isApplicationClientComponent(referencingJAR) || !JavaEEProjectUtilities.isApplicationClientComponent(referencedJAR);
}
protected void initializeElements() {
// ejbToClientJARs = J2EEProjectUtilities.collectEJBClientJARs(getEARFile());
ejbToClientJARs = new HashMap();
IVirtualComponent currentComponent = null;
IVirtualComponent clientComponent = null;
Object rootModelObject = null;
IModelProvider modelProvider = null;
String ejbClientJarName = null;
List archives = null;
IVirtualReference other = null;
ClasspathElement element = null;
String[] cp = new String[0];
IVirtualReference childProjectVirtualRef = null;
IVirtualReference[] references = null;
if (earComponent != null) {
references = earComponent.getReferences();
for (int cnt=0; cnt<references.length; cnt++)
{
clientComponent = null;
modelProvider = null;
rootModelObject = null;
ejbClientJarName = null;
currentComponent = references[cnt].getReferencedComponent();
if (JavaEEProjectUtilities.isEJBComponent(currentComponent))
{
if(currentComponent.isBinary()){
//TODO add binary support
continue;
}
modelProvider = ModelProviderManager.getModelProvider(currentComponent);
if(modelProvider==null) {
continue;
}
rootModelObject = modelProvider.getModelObject();
if (rootModelObject instanceof EJBJar)
{
ejbClientJarName = ((EJBJar)rootModelObject).getEjbClientJar();
}
else if (rootModelObject instanceof org.eclipse.jst.j2ee.ejb.EJBJar)
{
ejbClientJarName = ((org.eclipse.jst.j2ee.ejb.EJBJar)rootModelObject).getEjbClientJar();
}
if (ejbClientJarName != null)
{
clientComponent = J2EEProjectUtilities.getModule(earComponent, ejbClientJarName);
}
if (clientComponent != null)
{
ejbToClientJARs.put(currentComponent, clientComponent);
}
}
}
clientToEJBJARs = reverse(ejbToClientJARs);
classpathElements = new ArrayList();
urisToElements = new HashMap();
try {
// cp = archive.getManifest().getClassPathTokenized();
if( manifest == null ){
manifest = J2EEProjectUtilities.readManifest(component.getProject());
}
cp = manifest.getClassPathTokenized();
} catch (ManifestException ex) {
J2EEPlugin.logError(ex);
}
archives = new ArrayList(Arrays.asList(earComponent.getReferences()));
IPath earLibDirPath = null;
if(earLibraryDirectory != null)
earLibDirPath = new Path(earLibraryDirectory).makeRelative();
for( int i = 0; i < references.length; i++ ) {
if(references[i].getReferencedComponent().getProject().equals(component.getProject())) {
childProjectVirtualRef = references[i];
break;
}
}
for (int i = 0; i < cp.length; i++) {
String cpEntry = cp[i];
Path cpPath = new Path(cpEntry);
for( int j = 0; j < references.length; j++ ) {
if(references[j].getArchiveName().equals(cpPath.lastSegment())) {
other = references[j];
break;
}
}
String uriString = null;
if(other != null)
uriString = JEEManifestDiscerner.calculateManifestRelativeRuntimePath(childProjectVirtualRef, other).append((new Path(other.getArchiveName())).lastSegment()).toString();
if (other != null && isValidDependency(other.getReferencedComponent(), component) && (earLibraryDirectory == null || earLibDirPath != null && earLibDirPath.isEmpty() || !other.getRuntimePath().makeRelative().equals(earLibDirPath)) && (uriString == null || uriString.equals(cpEntry))) {
element = createElement(childProjectVirtualRef, other, cpEntry);
archives.remove(other);
} else {
element = createInvalidElement(cpEntry);
if (element.representsImportedJar()) {
element.setValid(true);
element.setProject(getProject(archive));
}
if (other != null)
element.setProject(other.getReferencedComponent().getProject());
if( other == null ){
//making a best guess for the project name
if( element.getProject() == null ){
int index = cpEntry.indexOf(IJ2EEModuleConstants.JAR_EXT);
// if jar is nested in a folder you must not look for
// project (segments in project name cause assertion
// error)
boolean isMultiSegment = cpEntry
.indexOf(File.pathSeparator) == -1;
if (!isMultiSegment && index > 0) {
String projectName = cpEntry.substring(0, index);
IPath projectPath = new Path(projectName);
//if there are multiple segments and no reference archive is found
//then either this is pointing to a jar in the EAR that doesn't exist
//or the DependecyGraphManager is stale
if(projectPath.segmentCount() > 1){
if(earComponent != null && earComponent.getProject() != null){
element.setProject(earComponent.getProject());
}
} else {
IProject project = ProjectUtilities.getProject( projectName );
if( project != null && project.exists() )
element.setProject( project );
}
}
}
}
}
addClasspathElement(element, element.getText());
}
}
// Add resolved contributions from tagged classpath entries
// XXX Don't show resolved contributions from tagged classpath entries on this project's classpath; we should elements corresponding to the raw entries instead
//createClasspathComponentDependencyElements(comp);
// Add elements for raw classpath entries (either already tagged or potentially taggable)
// try {
// createClasspathEntryElements(component, IClasspathDependencyConstants.RUNTIME_MAPPING_INTO_CONTAINER_PATH, IClasspathDependencyConstants.RUNTIME_MAPPING_INTO_COMPONENT_PATH);
// } catch (CoreException ce) {
// J2EEPlugin.logError(ce);
// }
if (earComponent != null) {
IPath earLibDirPath = null;
if(earLibraryDirectory != null)
earLibDirPath = new Path(earLibraryDirectory).makeRelative();
if(childProjectVirtualRef == null) {
if(references == null)
references = earComponent.getReferences();
for( int i = 0; i < references.length; i++ ) {
if(references[i].getReferencedComponent().getProject().equals(component.getProject())) {
childProjectVirtualRef = references[i];
break;
}
}
}
if(archives !=null){
Collections.sort(archives, comparator);
//Anything that remains in the list of available archives that is valid should be
//available for selection
for (int i = 0; i < archives.size(); i++) {
other = (IVirtualReference) archives.get(i);
if (other != archive && isValidDependency(other.getReferencedComponent(), component) && (earLibraryDirectory == null || earLibDirPath != null && earLibDirPath.isEmpty() || !other.getRuntimePath().makeRelative().equals(earLibDirPath))) {
IProject project = other.getReferencedComponent().getProject();
if (null == targetProjectName || null == project || !project.getName().equals(targetProjectName)) {
element = createElement(childProjectVirtualRef, other, null);
element.setProject(other.getReferencedComponent().getProject());
addClasspathElement(element, other.getArchiveName());
}
}
}
}
IVirtualReference[] newrefs = earComponent.getReferences();
for( int i=0; i < newrefs.length; i++){
IVirtualReference ref = newrefs[i];
IVirtualComponent referencedComponent = ref.getReferencedComponent();
boolean isBinary = referencedComponent.isBinary();
if( isBinary && (earLibraryDirectory == null || earLibDirPath != null && earLibDirPath.isEmpty() || !ref.getRuntimePath().makeRelative().equals(earLibDirPath))){
/**
* Warning clean-up 12/05/2005
*/
String unresolvedURI = null;
if(ref.getArchiveName() != null)
unresolvedURI = JEEManifestDiscerner.calculateManifestRelativeRuntimePath(childProjectVirtualRef, ref).append((new Path(ref.getArchiveName())).lastSegment()).toString();
if(unresolvedURI == null){
try {
unresolvedURI = ModuleURIUtil.getArchiveName(URI.createURI(ModuleURIUtil.getHandleString(referencedComponent)));
} catch (UnresolveableURIException e) {
J2EEPlugin.logError(e);
}
}
if(unresolvedURI != null){
URI archiveURI = URI.createURI(unresolvedURI);
boolean alreadyInList = false;
Iterator iter = getClasspathElements().iterator();
while(iter.hasNext()){
ClasspathElement tmpelement = (ClasspathElement)iter.next();
if(unresolvedURI.endsWith(tmpelement.getText())){
alreadyInList = true;
break;
}
}
if( !alreadyInList ){
if( inManifest(cp, archiveURI.lastSegment())){
element = createArchiveElement(archiveURI, unresolvedURI, archiveURI.lastSegment());
addClasspathElement(element, unresolvedURI);
}else{
element = createArchiveElement(archiveURI, unresolvedURI, null);
addClasspathElement(element, unresolvedURI);
}
}
}
}
}
}
}
public ClasspathElement createClasspathArchiveElement(final IProject project, URI archiveURI, String unresolvedURI) {
final ClasspathElement element = createArchiveElement(archiveURI, archiveURI.lastSegment(), archiveURI.lastSegment());
element.setProject(project);
element.setClasspathDependency(true);
return element;
}
public ClasspathElement createClasspathEntryElement(final IProject project, URI archiveURI, String elementName, IClasspathEntry entry) {
final ClasspathElement element = createArchiveElement(archiveURI, elementName, elementName);
element.setProject(project);
element.setClasspathEntry(true, entry);
element.setValid(true);
return element;
}
boolean inManifest(String[] cp, String archiveName ){
boolean result = false;
String cpEntry = ""; //$NON-NLS-1$
for (int i = 0; i < cp.length; i++) {
cpEntry = cp[i];
if( archiveName.equals(cpEntry)){
result = true;
}
}
return result;
}
protected List loadClassPathArchives(){
/**
* Warning clean-up 12/05/2005
*/
//LoadStrategy loadStrat = archive.getLoadStrategy();
List archives = new ArrayList();
if( earComponent!= null){
IVirtualReference[] newrefs = earComponent.getReferences();
for( int i=0; i < newrefs.length; i++){
IVirtualReference ref = newrefs[i];
IVirtualComponent referencedComponent = ref.getReferencedComponent();
boolean isBinary = referencedComponent.isBinary();
if( isBinary ){
String uri = J2EEProjectUtilities.getResolvedPathForArchiveComponent(referencedComponent.getName()).toString();
try {
ZipFileLoadStrategyImpl strat = createLoadStrategy(uri);
Archive archive = null;
try {
archive = CommonarchiveFactory.eINSTANCE.primOpenArchive(strat, uri);
} catch (OpenFailureException e) {
J2EEPlugin.logError(e);
}
archives.add(archive);
} catch (FileNotFoundException e) {
J2EEPlugin.logError(e);
} catch (IOException e) {
J2EEPlugin.logError(e);
}
}
}
}
return archives;
}
Archive getClassPathArchive(String uri, List archives){
for (int i = 0; i < archives.size(); i++) {
Archive anArchive = (Archive) archives.get(i);
String archiveURIString = anArchive.getURI();
URI archiveURI = URI.createURI(archiveURIString);
boolean hasAbsolutePath = archiveURI.hasAbsolutePath();
if( hasAbsolutePath ){
archiveURIString = archiveURI.lastSegment();
}
if (archiveURIString.equals(uri))
return anArchive;
}
return null;
}
boolean isClassPathArchive(String uri, List archives){
for (int i = 0; i < archives.size(); i++) {
Archive anArchive = (Archive) archives.get(i);
String archiveURIString = anArchive.getURI();
URI archiveURI = URI.createURI(archiveURIString);
/**
* Warning clean-up 12/05/2005
*/
//boolean hasAbsolutePath = archiveURI.hasAbsolutePath();
if( archiveURI.lastSegment().equals(uri) ){
return true;
}
}
return false;
}
public ZipFileLoadStrategyImpl createLoadStrategy(String uri) throws FileNotFoundException, IOException {
String filename = uri.replace('/', java.io.File.separatorChar);
java.io.File file = new java.io.File(filename);
if (!file.exists()) {
throw new FileNotFoundException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.file_not_found_EXC_, (new Object[]{uri, file.getAbsolutePath()}))); // = "URI Name: {0}; File name: {1}"
}
if (file.isDirectory()) {
throw new FileNotFoundException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.file_not_found_EXC_, (new Object[]{uri, file.getAbsolutePath()}))); // = "URI Name: {0}; File name: {1}"
}
return new org.eclipse.jst.j2ee.commonarchivecore.internal.strategy.ZipFileLoadStrategyImpl(file);
}
private void initializeEARProject(EARFile earFile) {
LoadStrategy loadStrat = earFile.getLoadStrategy();
if (loadStrat instanceof EARComponentLoadStrategyImpl){
earComponent = ((EARComponentLoadStrategyImpl) loadStrat).getComponent();
earProject = ((EARComponentLoadStrategyImpl) loadStrat).getComponent().getProject();
refreshEARLibraryDirectory();
}
}
private void refreshEARLibraryDirectory(){
earLibraryDirectory = EarUtilities.getEARLibDir(earComponent);
}
private void setType(ClasspathElement element, Archive other) {
if (other == null)
return;
else if (clientToEJBJARs.containsKey(other))
element.setJarType(ClasspathElement.EJB_CLIENT_JAR);
else if (other.isEJBJarFile())
element.setJarType(ClasspathElement.EJB_JAR);
}
private void setType(ClasspathElement element, IVirtualReference other) {
if (other == null)
return;
else if (clientToEJBJARs.containsKey(other.getReferencedComponent()))
element.setJarType(ClasspathElement.EJB_CLIENT_JAR);
else if (JavaEEProjectUtilities.isEJBComponent(other.getReferencedComponent()))
element.setJarType(ClasspathElement.EJB_JAR);
}
/**
* @param localejbToClientJARs
* @return
*/
private Map reverse(Map localejbToClientJARs) {
if (localejbToClientJARs == null || localejbToClientJARs.isEmpty())
return Collections.EMPTY_MAP;
Map result = new HashMap();
Iterator iter = localejbToClientJARs.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry entry = (Map.Entry) iter.next();
result.put(entry.getValue(), entry.getKey());
}
return result;
}
public void addClasspathElement(ClasspathElement element, String uri) {
getClasspathElements().add(element);
getUrisToElements().put(uri, element);
element.setParentSelection(this);
}
/**
* Insert the method's description here. Creation date: (8/22/2001 6:05:11 PM)
*
* @return boolean
*/
public boolean isModified() {
return modified;
}
/**
* Insert the method's description here. Creation date: (8/22/2001 6:05:11 PM)
*
* @param newModified
* boolean
*/
public void setModified(boolean newModified) {
modified = newModified;
}
protected void setProjectValues(ClasspathElement element, Archive referencedArchive) {
IProject p = getProject(referencedArchive);
if (p == null)
return;
element.setProject(p);
//Handle the imported jars in the project
String[] cp = null;
try {
cp = referencedArchive.getManifest().getClassPathTokenized();
} catch (ManifestException mfEx) {
J2EEPlugin.logError(mfEx);
cp = new String[]{};
}
List paths = new ArrayList(cp.length);
for (int i = 0; i < cp.length; i++) {
IFile file = null;
try {
file = p.getFile(cp[i]);
} catch (IllegalArgumentException invalidPath) {
continue;
}
if (file.exists())
paths.add(file.getFullPath());
}
if (!paths.isEmpty())
element.setImportedJarPaths(paths);
}
protected void setProjectValues(ClasspathElement element, IVirtualReference referencedArchive) {
IProject p = referencedArchive.getReferencedComponent().getProject();
if (p == null)
return;
element.setProject(p);
IVirtualComponent comp = ComponentCore.createComponent(p);
if( comp == null )
return;
//Handle the imported jars in the project
String[] cp = null;
try {
// cp = referencedArchive.getManifest().getClassPathTokenized();
ArchiveManifest referencedManifest = null;
if( comp.isBinary() ){
referencedManifest = J2EEProjectUtilities.readManifest(comp);
}else{
referencedManifest = J2EEProjectUtilities.readManifest(p);
}
if( referencedManifest != null )
cp = referencedManifest.getClassPathTokenized();
} catch (ManifestException mfEx) {
J2EEPlugin.logError(mfEx);
cp = new String[]{};
}
if( cp != null ){
List paths = new ArrayList(cp.length);
for (int i = 0; i < cp.length; i++) {
IFile file = null;
try {
file = p.getFile(cp[i]);
} catch (IllegalArgumentException invalidPath) {
continue;
}
if (file.exists())
paths.add(file.getFullPath());
}
if (!paths.isEmpty())
element.setImportedJarPaths(paths);
}
}
@Override
public String toString() {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < classpathElements.size(); i++) {
ClasspathElement element = (ClasspathElement) classpathElements.get(i);
if (element.isSelected() && !element.isClasspathDependency() && !element.isClasspathEntry()) {
sb.append(element.getRelativeText());
sb.append(" "); //$NON-NLS-1$
}
}
//Remove the trailing space
if (sb.length() > 0)
sb.deleteCharAt(sb.length() - 1);
return sb.toString();
}
public void setAllSelected(boolean selected) {
setAllSelected(classpathElements, selected);
}
public void setAllSelected(List elements, boolean selected) {
for (int i = 0; i < elements.size(); i++) {
ClasspathElement elmt = (ClasspathElement) elements.get(i);
elmt.setSelected(selected);
}
}
/* borrowed code from jdt */
protected List moveUp(List elements, List move) {
int nElements = elements.size();
List res = new ArrayList(nElements);
Object floating = null;
for (int i = 0; i < nElements; i++) {
Object curr = elements.get(i);
if (move.contains(curr)) {
res.add(curr);
} else {
if (floating != null) {
res.add(floating);
}
floating = curr;
}
}
if (floating != null) {
res.add(floating);
}
return res;
}
/* borrowed code from jdt */
public void moveUp(List toMoveUp) {
setModifiedIfAnySelected(toMoveUp);
if (toMoveUp.size() > 0)
classpathElements = moveUp(classpathElements, toMoveUp);
}
/* borrowed code from jdt */
public void moveDown(List toMoveDown) {
setModifiedIfAnySelected(toMoveDown);
if (toMoveDown.size() > 0)
classpathElements = reverse(moveUp(reverse(classpathElements), toMoveDown));
}
/* borrowed code from jdt */
protected List reverse(List p) {
List reverse = new ArrayList(p.size());
for (int i = p.size() - 1; i >= 0; i--) {
reverse.add(p.get(i));
}
return reverse;
}
public ClasspathElement getClasspathElement(String uri) {
if (urisToElements == null)
return null;
return (ClasspathElement) urisToElements.get(uri);
}
public ClasspathElement getClasspathElement(IVirtualComponent archiveComponent) {
if (archiveComponent != null) {
for (int i = 0; i < classpathElements.size(); i++) {
ClasspathElement elmnt = (ClasspathElement) classpathElements.get(i);
if (archiveComponent.equals(elmnt.getComponent()))
return elmnt;
}
}
return null;
}
public ClasspathElement getClasspathElement(IProject archiveProject) {
if (archiveProject != null) {
for (int i = 0; i < classpathElements.size(); i++) {
ClasspathElement elmnt = (ClasspathElement) classpathElements.get(i);
if (archiveProject.equals(elmnt.getProject()))
return elmnt;
}
}
return null;
}
public boolean hasDirectOrIndirectDependencyTo(IProject archiveProject) {
ClasspathElement element = getClasspathElement(archiveProject);
if (element == null)
return false;
return hasDirectOrIndirectDependencyTo(element);
}
public boolean hasDirectOrIndirectDependencyTo(String jarName) {
ClasspathElement element = getClasspathElement(jarName);
if (element == null)
return false;
return hasDirectOrIndirectDependencyTo(element);
}
private boolean hasDirectOrIndirectDependencyTo(ClasspathElement element){
Archive anArchive = null;
if (element.isValid()) {
try {
EARFile earFile = getEARFile();
if( earFile != null ){
anArchive = (Archive) earFile.getFile(element.getText());
}
} catch (FileNotFoundException e) {
}
}
return anArchive != null && archive.hasClasspathVisibilityTo(anArchive);
}
public boolean isAnyJarSelected(int type) {
if (classpathElements != null) {
for (int i = 0; i < classpathElements.size(); i++) {
ClasspathElement element = (ClasspathElement) classpathElements.get(i);
if (element.getJarType() == type && element.isSelected())
return true;
}
}
return false;
}
public boolean isAnyEJBJarSelected() {
return isAnyJarSelected(ClasspathElement.EJB_JAR);
}
public boolean isAnyEJBClientJARSelected() {
return isAnyJarSelected(ClasspathElement.EJB_CLIENT_JAR);
}
/**
* @return
*/
public int getFilterLevel() {
return filterLevel;
}
/**
* @param i
*/
public void setFilterLevel(int i) {
filterLevel = i;
}
/**
* This method selects or deselects indivual elements based on the filter level, and
* additionally sets the filter level.
*
* @param i
*/
public void selectFilterLevel(int level) {
setFilterLevel(level);
switch (level) {
case FILTER_EJB_CLIENT_JARS :
invertClientJARSelections(ClasspathElement.EJB_CLIENT_JAR);
break;
case FILTER_EJB_SERVER_JARS :
invertClientJARSelections(ClasspathElement.EJB_JAR);
break;
default :
break;
}
}
public void invertClientJARSelection(IProject aProject, IProject opposite) {
ClasspathElement element = getClasspathElement(aProject);
ClasspathElement oppositeElement = (opposite == null ? null : getClasspathElement(opposite));
if (element.isSelected())
invertSelectionIfPossible(element, oppositeElement);
}
private void invertClientJARSelections(int elementType) {
if (classpathElements == null)
return;
for (int i = 0; i < classpathElements.size(); i++) {
ClasspathElement element = (ClasspathElement) classpathElements.get(i);
if (element.getJarType() == elementType && element.isSelected()) {
invertSelectionIfPossible(element, null);
}
}
}
/**
* @param element
* @param elementType
*/
private void invertSelectionIfPossible(ClasspathElement element, ClasspathElement opposite) {
if (element == null)
return;
ClasspathElement innerOpposite = opposite;
if (innerOpposite == null)
innerOpposite = getOppositeElement(element);
if (innerOpposite != null) {
innerOpposite.setSelected(true);
element.setSelected(false);
}
}
/**
* If the element represents an EJB client JAR, returns the corresponding server JAR. If the
* element represents an EJB server JAR, returns the corresponding client JAR.
*/
public ClasspathElement getOppositeElement(ClasspathElement element) {
String uri = element.getText();
IVirtualComponent target = element.getTargetComponent();
if (uri == null || target == null)
return null;
IVirtualComponent oppositeJAR = null;
switch (element.getJarType()) {
case (ClasspathElement.EJB_CLIENT_JAR) :
oppositeJAR = (IVirtualComponent) clientToEJBJARs.get(target);
break;
case (ClasspathElement.EJB_JAR) :
oppositeJAR = (IVirtualComponent) ejbToClientJARs.get(target);
break;
default :
break;
}
if (oppositeJAR != null)
return getClasspathElement(oppositeJAR);
return null;
}
private void setModifiedIfAnySelected(List elements) {
for (int i = 0; i < elements.size(); i++) {
ClasspathElement element = (ClasspathElement) elements.get(i);
if (element.isSelected())
setModified(true);
}
}
public boolean isMyClientJAR(ClasspathElement element) {
if (element == null || ejbToClientJARs == null)
return false;
IVirtualComponent myClientJar = (IVirtualComponent) ejbToClientJARs.get(component);
return myClientJar != null && myClientJar == element.getTargetComponent();
}
public Map getUrisToElements() {
if(urisToElements == null)
urisToElements = new HashMap();
return urisToElements;
}
}