/*******************************************************************************
* Copyright (c) 2007-2013 BEA Systems, Inc. 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:
* BEA Systems, Inc. - initial API and implementation
* Fred Bricon (Red Hat, Inc.) - 359385 : override classpath entry's archive name
*******************************************************************************/
package org.eclipse.jst.j2ee.classpathdep;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
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.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jst.common.internal.modulecore.IClasspathDependencyComponent;
import org.eclipse.jst.common.jdt.internal.javalite.IJavaProjectLite;
import org.eclipse.jst.common.jdt.internal.javalite.JavaCoreLite;
import org.eclipse.jst.j2ee.componentcore.J2EEModuleVirtualComponent;
import org.eclipse.jst.j2ee.internal.J2EEVersionConstants;
import org.eclipse.jst.j2ee.internal.classpathdep.ClasspathDependencyValidator;
import org.eclipse.jst.j2ee.internal.classpathdep.ClasspathDependencyVirtualComponent;
import org.eclipse.jst.j2ee.internal.classpathdep.ClasspathDependencyValidator.ClasspathDependencyValidatorData;
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.application.Application;
import org.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.internal.impl.ModuleURIUtil;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
import org.eclipse.wst.validation.internal.provisional.core.IMessage;
/**
* Contains utility code for working manipulating the WTP classpath component
* dependency attribute.
*/
public class ClasspathDependencyUtil implements IClasspathDependencyConstants {
/**
* This is equivalent to calling getRawComponentClasspathDependencies(javaProject, DependencyAttributeType.CLASSPATH_COMPONENT_DEPENDENCY);
*
* @deprecated use {@link #getRawComponentClasspathDependencies(IJavaProject, org.eclipse.jst.j2ee.classpathdep.IClasspathDependencyConstants.DependencyAttributeType)}
*
* @param javaProject
* @return
* @throws CoreException
*/
@Deprecated
public static Map <IClasspathEntry, IClasspathAttribute> getRawComponentClasspathDependencies(final IJavaProject javaProject) throws CoreException {
return getRawComponentClasspathDependencies(javaProject, DependencyAttributeType.CLASSPATH_COMPONENT_DEPENDENCY);
}
/**
* @deprecated use {@link #getRawComponentClasspathDependencies(IJavaProjectLite, org.eclipse.jst.j2ee.classpathdep.IClasspathDependencyConstants.DependencyAttributeType)}
* @param javaProject
* @param attributeType
* @return
* @throws CoreException
*/
@Deprecated
public static Map <IClasspathEntry, IClasspathAttribute> getRawComponentClasspathDependencies(final IJavaProject javaProject, DependencyAttributeType attributeType) throws CoreException {
return getRawComponentClasspathDependencies(JavaCoreLite.create(javaProject), attributeType);
}
/**
* Returns all unresolved classpath entries for the specified Java project that
* have the special WTP classpath component dependency attribute.
*
* @param javaProjectLite Java project whose component classpath dependencies are being retrieved.
* @parem attributeType the attribute to search for
* @return Map from IClasspathEntry to IClasspathAttribute for classpath component dependency.
* @return IClasspathEntries with the special component dependency attribute.
* @throws CoreException Thrown if an error is encountered accessing the unresolved classpath.
*/
public static Map <IClasspathEntry, IClasspathAttribute> getRawComponentClasspathDependencies(final IJavaProjectLite javaProjectLite, DependencyAttributeType attributeType) throws CoreException {
return getRawComponentClasspathDependencies(javaProjectLite, attributeType, false);
}
public static Map <IClasspathEntry, IClasspathAttribute> getRawComponentClasspathDependencies(final IJavaProjectLite javaProjectLite, DependencyAttributeType attributeType, final boolean isLegacyJ2EE) throws CoreException {
if (javaProjectLite == null) {
return Collections.emptyMap();
}
final Map<IClasspathEntry, IClasspathAttribute> referencedRawEntries = new HashMap<IClasspathEntry, IClasspathAttribute>();
final IClasspathEntry[] entries = javaProjectLite.readRawClasspath();
for (IClasspathEntry entry : entries) {
final IClasspathAttribute attrib = checkForComponentDependencyAttribute(entry, attributeType, isLegacyJ2EE);
if (attrib != null) {
referencedRawEntries.put(entry, attrib);
}
}
return referencedRawEntries;
}
/**
* @deprecated use {@link #getPotentialComponentClasspathDependencies(IJavaProjectLite)}
* @param javaProject
* @return
* @throws CoreException
*/
@Deprecated
public static List <IClasspathEntry> getPotentialComponentClasspathDependencies(final IJavaProject javaProject) throws CoreException {
return getPotentialComponentClasspathDependencies(JavaCoreLite.create(javaProject));
}
/**
* Retrieves the unresolved classpath entries for the specified Java project that
* could potentially be mapped into the virtual component tree for the project via
* the special WTP classpath component dependence attribute. Classpath entries that
* currently have the attribute are not returned by this method (@see {@link #getRawComponentClasspathDependencies(IJavaProject, boolean)})
*
* @param javaProjectLite Java project whose potential component classpath dependencies will be retrieved.
* @return List of raw IClasspathEntries for potential classpath component dependencies.
* @throws CoreException Thrown if an error is encountered.
*/
public static List <IClasspathEntry> getPotentialComponentClasspathDependencies(final IJavaProjectLite javaProjectLite) throws CoreException {
return getPotentialComponentClasspathDependencies(javaProjectLite, false);
}
public static List <IClasspathEntry> getPotentialComponentClasspathDependencies(final IJavaProjectLite javaProjectLite, final boolean isLegacyJ2EE) throws CoreException {
final List <IClasspathEntry> potentialRawEntries = new ArrayList<IClasspathEntry>();
if (javaProjectLite == null || !javaProjectLite.getProject().isAccessible()) {
return Collections.emptyList();
}
final IProject project = javaProjectLite.getProject();
final boolean isWebApp = JavaEEProjectUtilities.isDynamicWebProject(project);
final boolean isRAR = JavaEEProjectUtilities.isJCAProject(project);
final ClasspathDependencyValidatorData data = new ClasspathDependencyValidatorData(project);
final IClasspathEntry[] entries = javaProjectLite.readRawClasspath();
for (int i = 0; i < entries.length; i++) {
final IClasspathEntry entry = entries[i];
final IClasspathAttribute attrib = checkForComponentDependencyAttribute(entry, DependencyAttributeType.DEPENDENCY_OR_NONDEPENDENCY, isLegacyJ2EE);
if (attrib != null) {
continue; // already has the attribute
}
// check validation logic for entry
// always mark the "isWebApp" param as true so that we get both exported and non-exported entries; for non-web projects,
// want to let a user have the option to see and select the non-exported entries and then just generate a validation
// error if they happen to select one.
final IMessage[] msgs = ClasspathDependencyValidator.validateVirtualComponentEntry(entry, null, true, project, data);
boolean error = false;
for (int j = 0; j < msgs.length; j++) {
if (msgs[j].getSeverity() == IMessage.HIGH_SEVERITY) {
error = true;
break;
}
}
if (error) {
continue;
}
if (IClasspathEntry.CPE_LIBRARY == entry.getEntryKind()) {
final boolean isFile = !ClasspathDependencyUtil.isClassFolderEntry(entry);
if (isFile) {
boolean foundEntry = false;
IVirtualComponent component = ComponentCore.createComponent(project);
if (isWebApp) { // checks for web libs
IContainer[] webLibFolders = component.getRootFolder().getFolder(WEB_INF_LIB_PATH).getUnderlyingFolders();
for (IContainer webLib : webLibFolders) {
IPath webLibFolderPath = webLib.getFullPath();
if (webLibFolderPath.equals(entry.getPath().removeLastSegments(1))) {
foundEntry = true;
break;
}
}
} else if(isRAR){
IContainer [] rootFolders = component.getRootFolder().getUnderlyingFolders();
for(IContainer root: rootFolders){
IPath rootPath = root.getFullPath();
if(rootPath.isPrefixOf(entry.getPath())){
foundEntry = true;
break;
}
}
}
if (foundEntry) {
continue;
}
// checks for manifest references
List manifestRefs = J2EEModuleVirtualComponent.getManifestReferences(component, null);
if(manifestRefs != null){
for (int j = 0; j < manifestRefs.size(); j++) {
IVirtualReference ref = (IVirtualReference) manifestRefs.get(j);
IVirtualComponent c = ref.getReferencedComponent();
if (c.isBinary()) {
IFile file = (IFile)c.getAdapter(IFile.class);
if (file != null && file.getFullPath().equals(entry.getPath())) {
foundEntry = true;
break;
}
}
}
if (foundEntry) {
continue;
}
}
// checks for ear library-directory entries
IProject[] earProjects = EarUtilities.getReferencingEARProjects(project);
for (IProject earProject : earProjects) {
String earDDVersion = EarUtilities.getJ2EEDDProjectVersion(earProject);
if(!earDDVersion.equals(J2EEVersionConstants.VERSION_1_2_TEXT) && !earDDVersion.equals(J2EEVersionConstants.VERSION_1_3_TEXT) && !earDDVersion.equals(J2EEVersionConstants.VERSION_1_4_TEXT)) {
IVirtualComponent earComponent = ComponentCore.createComponent(earProject);
Application app = (Application) ModelProviderManager.getModelProvider(earComponent).getModelObject();
String libDir = app.getLibraryDirectory();
if (libDir == null) {
// lib is the default if no library-directory is set
libDir = "lib"; //$NON-NLS-1$
}
IContainer[] earLibFolders = earComponent.getRootFolder().getFolder(new Path(libDir)).getUnderlyingFolders();
for (IContainer earLib : earLibFolders) {
IPath earLibFolderPath = earLib.getFullPath();
if (earLibFolderPath.equals(entry.getPath().removeLastSegments(1))) {
foundEntry = true;
break;
}
}
if (foundEntry) {
break;
}
}
}
if (foundEntry) {
continue;
}
}
}
// entry can potentially be tagged as a component dependency
potentialRawEntries.add(entry);
}
return potentialRawEntries;
}
private static boolean isValid(final IClasspathEntry entry, final IClasspathAttribute attrib, final boolean isWebApp, final IProject project, final ClasspathDependencyValidatorData data) {
final IMessage[] msgs = ClasspathDependencyValidator.validateVirtualComponentEntry(entry, attrib, isWebApp, project, data);
boolean valid = true;
for (int j = 0; j < msgs.length; j++) {
if (msgs[j].getSeverity() == IMessage.HIGH_SEVERITY) {
valid = false;
break;
}
}
return valid;
}
/**
* Returns all resolved classpath entries for the specified Java project that
* have one of the special WTP classpath component dependency attributes and pass the set of rules
* that govern valid classpath dependencies.
*
* @param javaProject Java project whose component classpath dependencies are being retrieved.
* @param isWebApp True if the target project is associated with a web project.
* @return Map from IClasspathEntry to IClasspathAttribute for classpath component dependencies.
* @throws CoreException Thrown if an error is encountered accessing the unresolved classpath.
*/
public static Map <IClasspathEntry, IClasspathAttribute> getComponentClasspathDependencies(final IJavaProjectLite javaProjectLite, final boolean isLegacyJ2EE) throws CoreException {
return getComponentClasspathDependencies(javaProjectLite, isLegacyJ2EE, true);
}
/**
* @deprecated use {@link #getComponentClasspathDependencies(IJavaProjectLite, boolean)}
* @param javaProject
* @param isWebApp
* @return
* @throws CoreException
*/
@Deprecated
public static Map <IClasspathEntry, IClasspathAttribute> getComponentClasspathDependencies(final IJavaProject javaProject, final boolean isLegacyJ2EE) throws CoreException {
return getComponentClasspathDependencies(JavaCoreLite.create(javaProject), isLegacyJ2EE);
}
/**
* @deprecated use {@link #getComponentClasspathDependencies(IJavaProjectLite, boolean, boolean)}
* @param javaProject
* @param isWebApp
* @param onlyValid
* @return
* @throws CoreException
*/
@Deprecated
public static Map <IClasspathEntry, IClasspathAttribute> getComponentClasspathDependencies(final IJavaProject javaProject, final boolean isWebApp, final boolean onlyValid) throws CoreException {
return getComponentClasspathDependencies(JavaCoreLite.create(javaProject), isWebApp, onlyValid);
}
/**
* Returns all resolved classpath entries for the specified Java project that
* have one of the special WTP classpath component dependency attributes.
*
* @param javaProject Java project whose component classpath dependencies are being retrieved.
* @param isWebApp True if the target project is associated with a web project.
* @param onlyValid If true, only valid dependencies will be returned. If false, the raw entry must be valid but the
* resolved can be invalid.
* @return Map from IClasspathEntry to IClasspathAttribute for classpath component dependencies.
* @throws CoreException Thrown if an error is encountered accessing the unresolved classpath.
*/
public static Map <IClasspathEntry, IClasspathAttribute> getComponentClasspathDependencies(final IJavaProjectLite javaProjectLite, final boolean isLegacyJ2EE, final boolean onlyValid) throws CoreException {
final ClasspathDependencyValidatorData data = new ClasspathDependencyValidatorData(javaProjectLite.getProject());
final boolean isWebApp = JavaEEProjectUtilities.isDynamicWebProject(javaProjectLite.getProject());
// get the raw entries
final Map<IClasspathEntry, IClasspathAttribute> referencedRawEntries = getRawComponentClasspathDependencies(javaProjectLite, DependencyAttributeType.CLASSPATH_COMPONENT_DEPENDENCY, isLegacyJ2EE);
final Map<IClasspathEntry, IClasspathAttribute> validRawEntries = new HashMap<IClasspathEntry, IClasspathAttribute>();
final Map <IClasspathEntry, IClasspathAttribute> validRawClassPathContainerEntries = new HashMap <IClasspathEntry, IClasspathAttribute>();
// filter out non-valid referenced raw entries
final Iterator<IClasspathEntry> i = referencedRawEntries.keySet().iterator();
while (i.hasNext()) {
final IClasspathEntry entry = i.next();
final IClasspathAttribute attrib = referencedRawEntries.get(entry);
if (isValid(entry, attrib, isWebApp, javaProjectLite.getProject(), data)) {
if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER)
{
//Put in a separate map the classpath container entries, since they will be handled differently
validRawClassPathContainerEntries.put(entry, attrib);
}
else {
validRawEntries.put(entry, attrib);
}
}
}
// if we have no valid raw entries, return empty map
if (validRawEntries.isEmpty() && validRawClassPathContainerEntries.isEmpty()) {
return Collections.emptyMap();
}
// XXX Would like to replace the code below with use of a public JDT API that returns
// the raw IClasspathEntry for a given resolved IClasspathEntry (see see https://bugs.eclipse.org/bugs/show_bug.cgi?id=183995)
// The code must currently leverage IPackageFragmentRoot to determine this
// mapping and, because IPackageFragmentRoots do not maintain IClasspathEntry data, a prior
// call is needed to getResolvedClasspath() and the resolved IClasspathEntries have to be stored in a Map from IPath-to-IClasspathEntry to
// support retrieval using the resolved IPackageFragmentRoot
// retrieve the resolved classpath
//TODO this call to javaProject needs to be removed. Need to figure out what exactly this is attempting to do.
IJavaProject javaProject = JavaCore.create(javaProjectLite.getProject());
//TODO this call to javaProject needs to be removed. Need to figure out what exactly this is attempting to do.
final IClasspathEntry[] entries = javaProject.getResolvedClasspath(true);
final Map <IPath, IClasspathEntry> pathToResolvedEntry = new HashMap<IPath, IClasspathEntry>();
// store in a map from path to entry
for (int j = 0; j < entries.length; j++) {
pathToResolvedEntry.put(entries[j].getPath(), entries[j]);
}
//Gather all resolved entries from the package roots and the classpath containers
final Map <IClasspathEntry, IClasspathAttribute> resolvedEntries = new LinkedHashMap <IClasspathEntry, IClasspathAttribute>();
// grab all IPackageFragmentRoots
// TODO this ignores project cp entries; can easily add in the raw project cp entries, however, do not have a good way to
// map project cp entries resolved from cp containers back to the corresponding raw entry (and thereby determine if the
// entry has the publish/export attribute)
//TODO this call to javaProject needs to be removed. Need to figure out what exactly this is attempting to do.
final IPackageFragmentRoot[] roots = javaProject.getPackageFragmentRoots();
for (IPackageFragmentRoot root : roots) {
final IClasspathEntry rawEntry = root.getRawClasspathEntry();
// is the raw entry valid?
IClasspathAttribute attrib = validRawEntries.get(rawEntry);
if (attrib == null) {
continue;
}
final IPath pkgFragPath = root.getPath();
final IClasspathEntry resolvedEntry = pathToResolvedEntry.get(pkgFragPath);
resolvedEntries.put(resolvedEntry, attrib);
}
// Add entries coming from classpath containers to the list of resolved entries
for (Map.Entry <IClasspathEntry, IClasspathAttribute> entry : validRawClassPathContainerEntries.entrySet()) {
IClasspathContainer classpathContainer = JavaCore.getClasspathContainer(entry.getKey().getPath(), javaProject);
if(classpathContainer != null)
{
IClasspathEntry[] classpathContainerEntries = classpathContainer.getClasspathEntries();
if(classpathContainerEntries != null) {
for (int j = 0; j < classpathContainerEntries.length; j++) {
resolvedEntries.put(classpathContainerEntries[j], entry.getValue());
}
}
}
}
//Setup the final result
final Map <IClasspathEntry, IClasspathAttribute> referencedEntries = new LinkedHashMap <IClasspathEntry, IClasspathAttribute>();
for (Map.Entry <IClasspathEntry, IClasspathAttribute> mapEntry : resolvedEntries.entrySet()) {
final IClasspathEntry resolvedEntry = mapEntry.getKey();
IClasspathAttribute attrib = mapEntry.getValue();
final IClasspathAttribute resolvedAttrib = checkForComponentDependencyAttribute(resolvedEntry, DependencyAttributeType.DEPENDENCY_OR_NONDEPENDENCY, isLegacyJ2EE);
// attribute for the resolved entry must either be unspecified or it must be the
// dependency attribute for it to be included
if (resolvedAttrib == null || resolvedAttrib.getName().equals(CLASSPATH_COMPONENT_DEPENDENCY)) {
// filter out resolved entry if it doesn't pass the validation rules
if (!onlyValid || isValid(resolvedEntry, resolvedAttrib != null?resolvedAttrib:attrib,isWebApp, javaProjectLite.getProject(), data)) {
if (resolvedAttrib != null) {
// if there is an attribute on the sub-entry, use that
attrib = resolvedAttrib;
}
referencedEntries.put(resolvedEntry, attrib);
}
}
}
return referencedEntries;
}
/**
* Retrieves the location (as a absolute file system path) for the specified classpath entry.
* @param entry Classpath entry. If null, returns null.
* @return Absolute file system path.
*/
public static IPath getEntryLocation(final IClasspathEntry entry) {
if (entry == null) {
return null;
}
final IPath entryPath = entry.getPath();
IPath entryLocation = entryPath;
final IResource resource = ResourcesPlugin.getWorkspace().getRoot().findMember(entryPath);
if (resource != null) {
entryLocation = resource.getLocation();
}
return entryLocation;
}
/**
* Retrieves the IResource corresponding to the specified classpath entry or null if it does not represent a Workspace resource.
* @param entry Classpath entry. If null, returns null.
* @return IResource or null.
*/
public static IResource getEntryResource(final IClasspathEntry entry) {
if (entry == null) {
return null;
}
final IPath entryPath = entry.getPath();
return ResourcesPlugin.getWorkspace().getRoot().findMember(entryPath);
}
/**
* Checks if the specified IVirtualReference represents an project cp entry. If so, returns the underlying IProject, otherwise,
* returns null.
* @param ref The IVirtualReference
* @return IProject referenced by the project cp entry or null if the specified reference is null or does not refer to
* a VirtualArchiveComponent with type VirtualArchiveComponent.CLASSPATHARCHIVETYPE that represents a project cp entry.
*/
public static IProject isClasspathProjectReference(final IVirtualReference ref) {
if (ref != null && ref.getReferencedComponent() instanceof IClasspathDependencyComponent)
return ref.getReferencedComponent().getProject();
return null;
}
/**
* Checks if the specified classpath entry represents a class folder.
* @param entry The entry to check.
* @return True if it is a library entry that points to a class folder. False otherwise.
*/
public static boolean isClassFolderEntry(final IClasspathEntry entry) {
if (entry == null || entry.getEntryKind() != IClasspathEntry.CPE_LIBRARY) {
return false;
}
// does the path refer to a file or a folder?
final IPath entryPath = entry.getPath();
IPath entryLocation = entryPath;
final IResource resource = ResourcesPlugin.getWorkspace().getRoot().findMember(entryPath);
if (resource != null) {
entryLocation = resource.getLocation();
}
boolean isFile = true; // by default, assume a jar file
if (entryLocation.toFile().isDirectory()) {
isFile = false;
}
return !isFile;
}
/**
* Retrieves the location (as an absolute local file system path) for the classpath dependency represented
* by the specified IVirtualReference. Will return null for a project cp entry.
* @param ref The IVirtualReference
* @return Absolute path in the local file system or null if the specified reference is null or does not refer to
* a VirtualArchiveComponent with type VirtualArchiveComponent.CLASSPATHARCHIVETYPE.
*/
public static IPath getClasspathVirtualReferenceLocation(final IVirtualReference ref) {
if (ref != null && ref.getReferencedComponent() instanceof IClasspathDependencyComponent) {
return (IPath)ref.getReferencedComponent().getAdapter(IPath.class);
}
return null;
}
/**
* Retrieves the runtime path to which the resolved classpath entry components will be
* added within the deployed application.
* @param attrib The IClasspathAttribute with the WTP classpath component dependency value. If null,
* will return the default path.
* @param isWebApp True for web projects, false otherwise.
* @param isClassFolder True if the default value should be computed for a class folder. Ignored if calculating for
* a valid IClasspathAttribute.
* @return Runtime path. Will be null if the attribute is not a WTP classpath component dependency
* attribute.
*/
public static IPath getRuntimePath(final IClasspathAttribute attrib, final boolean isWebApp, final boolean isClassFolder) {
if (attrib != null && !attrib.getName().equals(CLASSPATH_COMPONENT_DEPENDENCY)) {
return null;
}
if (attrib == null || attrib.getValue()== null || attrib.getValue().length() == 0) {
return getDefaultRuntimePath(isWebApp, isClassFolder);
}
return new Path(attrib.getValue());
}
/**
* Checks if the specified IVirtualReference represents a class folder that has been marked for publish/export.
* @param ref IVirtualReference to test.
* @return True if this is a publish/export class folder.
*/
public static boolean isClassFolderReference(final IVirtualReference ref) {
final IVirtualComponent comp = ref.getReferencedComponent();
// must refer to a ClasspathDependencyVirtualComponent
if (comp instanceof ClasspathDependencyVirtualComponent) {
final ClasspathDependencyVirtualComponent cpComp= (ClasspathDependencyVirtualComponent) comp;
return cpComp.isClassFolder();
}
return false;
}
/**
* Returns the container for the specified VirtualArchiveComponent or null if this reference does not match to a container.
* @param comp IVirtualComponent.
* @return IContainer for the class folder or null if this reference does not match a container.
*/
public static IContainer getClassFolder(final IVirtualComponent comp) {
if (comp instanceof ClasspathDependencyVirtualComponent) {
final ClasspathDependencyVirtualComponent cpComp= (ClasspathDependencyVirtualComponent) comp;
return cpComp.getClassFolder();
}
return null;
}
/**
* Retrieves the default runtime path to which the resolved classpath entry components will be
* added within the deployed application. This method is only valid for non-class folder entries.
* @param isWebApp True if the default runtime path for web apps should be returned, false otherwise.
* @return The default runtime path.
*/
public static IPath getDefaultRuntimePath(final boolean isWebApp) {
return getDefaultRuntimePath(isWebApp, false);
}
/**
* Retrieves the default runtime path to which the resolved classpath entry components will be
* added within the deployed application.
* @param isWebApp True if the default runtime path for web apps should be returned, false otherwise.
* @param isClassFolder True if the path is a class folder.
* @return The default runtime path.
*/
public static IPath getDefaultRuntimePath(final boolean isWebApp, final boolean isClassFolder) {
if (isWebApp) {
return isClassFolder ? WEB_INF_CLASSES_PATH : WEB_INF_LIB_PATH;
}
return isClassFolder ? RUNTIME_MAPPING_INTO_COMPONENT_PATH : RUNTIME_MAPPING_INTO_CONTAINER_PATH;
}
public static IPath getDefaultRuntimePath(final IVirtualComponent virtualComponent, IClasspathEntry entry){
boolean isClassFolderEntry = isClassFolderEntry(entry);
if(virtualComponent == null){
//null, use default
return getDefaultRuntimePath(false, isClassFolderEntry);
}
boolean isWebApp = JavaEEProjectUtilities.isDynamicWebComponent(virtualComponent);
if(isWebApp || isClassFolderEntry){
return getDefaultRuntimePath(isWebApp, isClassFolderEntry);
}
//not a WAR
//if part of EE5 or greature ear, map into the EAR's lib folder
IProject [] earProjects = EarUtilities.getReferencingEARProjects(virtualComponent.getProject());
if (earProjects.length > 0) {
IVirtualComponent earComponent = ComponentCore.createComponent(earProjects[0]);
if (earComponent != null) {
return calculateDefaultRuntimePath(earComponent, virtualComponent);
}
}
return getDefaultRuntimePath(false, false);
}
public static IPath calculateDefaultRuntimePath(IVirtualComponent parentComponent, IVirtualComponent targetComponent) {
IVirtualReference targetRef = parentComponent.getReference(targetComponent.getName());
String libDir = EarUtilities.getEARLibDir(parentComponent);
if (libDir != null && libDir.length() > 0) {
IPath libDirPath = new Path(libDir);
// If project is at root level, go up a level and add lib dir path absolute path
if(targetRef == null || targetRef.getRuntimePath().equals("/")) //$NON-NLS-1$
return new Path(RUNTIME_MAPPING_INTO_CONTAINER).append(libDirPath.makeAbsolute());
IPath childProjectRuntimePath = targetRef.getRuntimePath();
String[] childProjectFolders = childProjectRuntimePath.segments();
String[] libFolders = libDirPath.segments();
int commonFolderCount = 0;
for(int i = 0; i < childProjectFolders.length; i++) {
if(i >= libFolders.length || !childProjectFolders[i].equals(libFolders[i]))
break;
commonFolderCount++;
}
String resultString = RUNTIME_MAPPING_INTO_CONTAINER;
for(int i = 0; i < childProjectFolders.length - commonFolderCount; i++) {
resultString += RUNTIME_MAPPING_INTO_CONTAINER;
}
return new Path(resultString).append(libDirPath.removeFirstSegments(commonFolderCount));
}
return getDefaultRuntimePath(false, false);
}
/**
* Retrieves the archive name for the specified classpath entry.
* For library entries, if a classpath attribute with {@link IClasspathDependencyConstants.CLASSPATH_ARCHIVENAME_ATTRIBUTE} was set,
* its value will be returned.
*
* @param entry The entry.
* @return The archive name.
*/
public static String getArchiveName(final IClasspathEntry entry) {
if (entry == null) {
return null;
}
final boolean isClassFolder = isClassFolderEntry(entry);
if (isClassFolder) {
IResource resource = getEntryResource(entry);
if (resource == null) {
return getEntryLocation(entry).lastSegment();
}
return resource.getFullPath().toString();
}
//bug 359385 : Override default archive name
String customArchiveName = getCustomArchiveName(entry);
if (customArchiveName != null) {
return customArchiveName;
}
final IPath entryLocation = getEntryLocation(entry);
return entryLocation.lastSegment();
}
private static String getCustomArchiveName(IClasspathEntry entry) {
IClasspathAttribute[] extraAttributes = entry.getExtraAttributes();
if (extraAttributes != null) {
for (IClasspathAttribute cpa : extraAttributes) {
if (cpa != null && CLASSPATH_ARCHIVENAME_ATTRIBUTE.equals(cpa.getName())) {
return cpa.getValue();
}
}
}
return null;
}
/**
* Checks if the specified IClasspathEntry has either of the special WTP component dependency
* attributes that indicate it should be mapped into the virtual component for the associated project.
*
* @param entry The IClasspathEntry.
* @return The IClasspathAttribute that holds the special WTP attribute or null if one was not found.
*/
public static IClasspathAttribute checkForComponentDependencyAttribute(final IClasspathEntry entry) {
return checkForComponentDependencyAttribute(entry, DependencyAttributeType.DEPENDENCY_OR_NONDEPENDENCY);
}
/**
* Checks if the specified IClasspathEntry has one of the special WTP component dependency
* attributes that indicate it should be mapped into the virtual component for the associated project.
*
* @param entry The IClasspathEntry.
* @param componentDependency Controls which type of dependency attribute should be checked for (or whether both should be checked).
* @return The IClasspathAttribute that holds the special WTP attribute or null if one was not found.
*/
public static IClasspathAttribute checkForComponentDependencyAttribute(final IClasspathEntry entry, final DependencyAttributeType attributeType) {
return checkForComponentDependencyAttribute(entry, attributeType, false);
}
public static IClasspathAttribute checkForComponentDependencyAttribute(final IClasspathEntry entry, final DependencyAttributeType attributeType, final boolean isLegacyJ2EE) {
if (entry == null)
return null;
final IClasspathAttribute[] attributes = entry.getExtraAttributes();
for (int i = 0; i < attributes.length; i++) {
final IClasspathAttribute attribute = attributes[i];
final String name = attribute.getName();
if (name.equals(CLASSPATH_COMPONENT_DEPENDENCY)) {
if (attributeType == DependencyAttributeType.DEPENDENCY_OR_NONDEPENDENCY
|| attributeType == DependencyAttributeType.CLASSPATH_COMPONENT_DEPENDENCY) {
return attribute;
}
} else if (name.equals(CLASSPATH_COMPONENT_NON_DEPENDENCY)) {
if (attributeType == DependencyAttributeType.DEPENDENCY_OR_NONDEPENDENCY
|| attributeType == DependencyAttributeType.CLASSPATH_COMPONENT_NONDEPENDENCY) {
return attribute;
}
}
}
return null;
}
/**
* Determines if the specified virtual component represents a classpath component dependency.
* @param component Virtual component to test
* @return True if a classpath component dependency, false otherwise.
*/
public static boolean isClasspathComponentDependency(final IVirtualComponent component) {
return component != null && component instanceof IClasspathDependencyComponent;
}
/**
* Retrieves the classpath component display string for the specified component.
* @param component Component that represents a classpath component.
* @return Display string.
*/
public static String getClasspathComponentDependencyDisplayString(final IVirtualComponent component) {
final URI archiveURI = URI.createURI(ModuleURIUtil.getHandleString(component));
return archiveURI.lastSegment();
}
public static boolean isMappedIntoContainer(String path) {
if (path.startsWith(IClasspathDependencyConstants.RUNTIME_MAPPING_INTO_CONTAINER))
return true;
return false;
}
public static IClasspathEntry modifyDependencyPath(IClasspathEntry entry, IPath dependencyPath){
IClasspathEntry newEntry = null;
IClasspathAttribute [] newAttributes = modifyDependencyPath(entry.getExtraAttributes(), dependencyPath);
switch(entry.getEntryKind()) {
case IClasspathEntry.CPE_CONTAINER:
newEntry = JavaCore.newContainerEntry(entry.getPath(), entry.getAccessRules(), newAttributes, entry.isExported());
break;
case IClasspathEntry.CPE_LIBRARY:
newEntry = JavaCore.newLibraryEntry(entry.getPath(), entry.getSourceAttachmentPath(), entry.getSourceAttachmentRootPath(), entry.getAccessRules(), newAttributes, entry.isExported());
break;
case IClasspathEntry.CPE_VARIABLE:
newEntry = JavaCore.newVariableEntry(entry.getPath(), entry.getSourceAttachmentPath(), entry.getSourceAttachmentRootPath(), entry.getAccessRules(), newAttributes, entry.isExported());
break;
case IClasspathEntry.CPE_PROJECT:
newEntry = JavaCore.newProjectEntry(entry.getPath(), entry.getAccessRules(), entry.combineAccessRules(), newAttributes, entry.isExported());
break;
case IClasspathEntry.CPE_SOURCE:
newEntry = JavaCore.newSourceEntry(entry.getPath(), entry.getInclusionPatterns(), entry.getExclusionPatterns(), entry.getOutputLocation(), newAttributes);
break;
}
return newEntry;
}
public static IPath getRuntimePath(final IClasspathEntry entry){
IClasspathAttribute [] attributes = entry.getExtraAttributes();
for(IClasspathAttribute attribute : attributes){
if(attribute.getName().equals(CLASSPATH_COMPONENT_DEPENDENCY)){
return new Path(attribute.getValue());
}
}
return null;
}
private static IClasspathAttribute[] modifyDependencyPath(final IClasspathAttribute[] currentAttributes, IPath runtimePath) {
final List <IClasspathAttribute> updatedAttributes = new ArrayList<IClasspathAttribute> ();
boolean modified = false;
for(IClasspathAttribute currentAttribute : currentAttributes){
if(currentAttribute.getName().equals(CLASSPATH_COMPONENT_DEPENDENCY)){
modified = true;
if(runtimePath == null){
continue;
}
try {
IClasspathAttribute newAttribute = UpdateClasspathAttributeUtil.createDependencyAttribute(runtimePath);
updatedAttributes.add(newAttribute);
} catch (CoreException e) {
org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin.logError(e);
}
} else {
updatedAttributes.add(currentAttribute);
}
}
if(!modified){
try {
IClasspathAttribute newAttribute = UpdateClasspathAttributeUtil.createDependencyAttribute(runtimePath);
updatedAttributes.add(newAttribute);
} catch (CoreException e) {
org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin.logError(e);
}
}
return updatedAttributes.toArray(new IClasspathAttribute[updatedAttributes.size()]);
}
}