| /******************************************************************************* |
| * Copyright (c) 2003, 2011 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.componentcore; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| 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.IProject; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.jdt.core.IClasspathAttribute; |
| import org.eclipse.jdt.core.IClasspathEntry; |
| import org.eclipse.jst.common.internal.modulecore.IClasspathDependencyComponent; |
| import org.eclipse.jst.common.internal.modulecore.IClasspathDependencyProvider; |
| import org.eclipse.jst.common.internal.modulecore.IClasspathDependencyReceiver; |
| import org.eclipse.jst.common.internal.modulecore.util.ManifestUtilities; |
| import org.eclipse.jst.common.jdt.internal.javalite.IJavaProjectLite; |
| import org.eclipse.jst.common.jdt.internal.javalite.JavaCoreLite; |
| import org.eclipse.jst.common.jdt.internal.javalite.JavaLiteUtilities; |
| import org.eclipse.jst.j2ee.classpathdep.ClasspathDependencyUtil; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.util.ArchiveUtil; |
| import org.eclipse.jst.j2ee.internal.J2EEConstants; |
| import org.eclipse.jst.j2ee.internal.classpathdep.ClasspathDependencyVirtualComponent; |
| import org.eclipse.jst.j2ee.internal.common.J2EEDependencyListener; |
| import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin; |
| import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities; |
| import org.eclipse.jst.j2ee.project.EarUtilities; |
| import org.eclipse.jst.j2ee.project.JavaEEProjectUtilities; |
| import org.eclipse.wst.common.componentcore.ComponentCore; |
| import org.eclipse.wst.common.componentcore.internal.builder.IDependencyGraph; |
| import org.eclipse.wst.common.componentcore.internal.resources.VirtualArchiveComponent; |
| import org.eclipse.wst.common.componentcore.internal.resources.VirtualComponent; |
| import org.eclipse.wst.common.componentcore.internal.resources.VirtualFolder; |
| import org.eclipse.wst.common.componentcore.internal.resources.VirtualReference; |
| import org.eclipse.wst.common.componentcore.internal.util.IComponentImplFactory; |
| import org.eclipse.wst.common.componentcore.internal.util.VirtualReferenceUtilities; |
| import org.eclipse.wst.common.componentcore.resources.ITaggedVirtualResource; |
| import org.eclipse.wst.common.componentcore.resources.IVirtualComponent; |
| import org.eclipse.wst.common.componentcore.resources.IVirtualFolder; |
| import org.eclipse.wst.common.componentcore.resources.IVirtualReference; |
| |
| public class J2EEModuleVirtualComponent extends VirtualComponent implements IComponentImplFactory, IClasspathDependencyProvider, IClasspathDependencyReceiver { |
| |
| public static final String DD_FOLDER_TAG = org.eclipse.wst.common.componentcore.internal.WorkbenchComponent.DEFAULT_ROOT_SOURCE_TAG; |
| public static String GET_JAVA_REFS = "GET_JAVA_REFS"; //$NON-NLS-1$ |
| public static String GET_FUZZY_EAR_REFS = "GET_FUZZY_EAR_REFS"; //$NON-NLS-1$ |
| public static String GET_EXPANDED_LIB_REFS = "GET_EXPANDED_LIB_REFS"; //$NON-NLS-1$ |
| /** |
| * Use this value to retrieve references consisting of only META-INF/MANIFEST.MF classpath |
| * attributes. Do this as follows: |
| * <code> |
| * IVirtualCompoment component = a virtual component |
| * Map<String, Object> onlyManifestRefs = new HashMap<String, Object>(); |
| * onlyManifestRefs.put(IVirtualComponent.REQUESTED_REFERENCE_TYPE, J2EEModuleVirtualComponent.ONLY_MANIFEST_REFERENCES); |
| * IVirtualReference[] refs = component.getReferences(onlyManifestRefs); |
| * </code> |
| */ |
| public static String ONLY_MANIFEST_REFERENCES = "ONLY_MANIFEST_REFERENCES"; //$NON-NLS-1$ |
| |
| private long depGraphModStamp; |
| private long jeeModStamp; |
| |
| /** |
| * Accessors of this field should always use getHardReferences() |
| */ |
| private IVirtualReference[] hardReferences = null; |
| private IVirtualReference[] javaReferences = null; |
| private IVirtualReference[] parentEarManifestReferences = null; |
| private IVirtualReference[] fuzzyEarManifestReferences = null; |
| |
| public J2EEModuleVirtualComponent() { |
| super(); |
| } |
| |
| public J2EEModuleVirtualComponent(IProject aProject, IPath aRuntimePath) { |
| super(aProject, aRuntimePath); |
| } |
| |
| public IVirtualComponent createComponent(IProject aProject) { |
| return new J2EEModuleVirtualComponent(aProject, new Path("/")); //$NON-NLS-1$ |
| } |
| |
| public IVirtualComponent createArchiveComponent(IProject aProject, String archiveLocation, IPath aRuntimePath) { |
| return new J2EEModuleVirtualArchiveComponent(aProject, archiveLocation, aRuntimePath); |
| } |
| |
| public IVirtualFolder createFolder(IProject aProject, IPath aRuntimePath) { |
| return new VirtualFolder(aProject, aRuntimePath); |
| } |
| |
| /** |
| * Retrieves all references except those computed dynamically from |
| * tagged Java classpath entries. |
| * @return IVirtualReferences for all non-Java classpath entry references. |
| */ |
| public IVirtualReference[] getNonJavaReferences() { |
| return getReferences(false,false); |
| } |
| |
| protected IVirtualReference[] getHardReferences() { |
| if (!checkIfStillValid() || hardReferences == null) { |
| Map<String, Object> map = new HashMap<String, Object>(); |
| map.put(REQUESTED_REFERENCE_TYPE, HARD_REFERENCES); |
| hardReferences = super.getReferences(map); |
| } |
| return hardReferences; |
| } |
| |
| protected static IVirtualReference[] getHardReferences( |
| IVirtualComponent component) { |
| Map<String, Object> map = new HashMap<String, Object>(); |
| map.put(REQUESTED_REFERENCE_TYPE, HARD_REFERENCES); |
| return component.getReferences(map); |
| } |
| |
| public IVirtualReference[] getJavaClasspathReferences() { |
| //broken by cache |
| //if (javaReferences == null || !checkIfStillValid()) |
| javaReferences = getJavaClasspathReferences(getHardReferences()); |
| return javaReferences; |
| } |
| |
| @Override |
| public IVirtualReference[] getReferences(Map<String, Object> options) { |
| Object val = options.get(REQUESTED_REFERENCE_TYPE); |
| if( val != null ) { |
| if( HARD_REFERENCES.equals(val) || NON_DERIVED_REFERENCES.equals(val) || DISPLAYABLE_REFERENCES.equals(val)){ |
| return getHardReferences(); |
| } else if(DISPLAYABLE_REFERENCES_ALL.equals(val)){ |
| checkIfStillValid(); // This will clear the cache of raw references if needed. |
| return getAllReferences(); |
| } else if (ONLY_MANIFEST_REFERENCES.equals(val)){ |
| ArrayList<IVirtualReference> all = new ArrayList<IVirtualReference>(); |
| checkIfStillValid(); |
| cacheManifestReferences(); |
| all.addAll(Arrays.asList(parentEarManifestReferences)); |
| all.addAll(Arrays.asList(fuzzyEarManifestReferences)); |
| IVirtualReference[] refs = all.toArray(new IVirtualReference[all.size()]); |
| VirtualReferenceUtilities.INSTANCE.ensureReferencesHaveNames(refs); |
| return refs; |
| } |
| } |
| Boolean objGetJavaRefs = (Boolean)options.get(GET_JAVA_REFS); |
| Boolean objGetFuzzyEarRefs = (Boolean)options.get(GET_FUZZY_EAR_REFS); |
| Boolean objGetExpandRefs = (Boolean)options.get(GET_EXPANDED_LIB_REFS); |
| boolean getJavaRefs = objGetJavaRefs != null ? objGetJavaRefs.booleanValue() : true; |
| boolean findFuzzyEARRefs = objGetFuzzyEarRefs != null ? objGetFuzzyEarRefs.booleanValue() : false; |
| boolean getExpandRefs = objGetExpandRefs != null ? objGetExpandRefs.booleanValue() : false; |
| |
| IVirtualReference[] nonManifestRefs = getNonManifestRefs(getJavaRefs); |
| if (val != null && FLATTENABLE_REFERENCES.equals(val)) { |
| if (getExpandRefs) { |
| return JavaEEProjectUtilities.getExpandedReferences(this, nonManifestRefs); |
| } |
| return nonManifestRefs; |
| } |
| ArrayList<IVirtualReference> all = new ArrayList<IVirtualReference>(); |
| all.addAll(Arrays.asList(nonManifestRefs)); |
| // retrieve the dynamic references specified via the MANIFEST.MF classpath |
| cacheManifestReferences(); |
| ArrayList<IVirtualReference> dynamicRefs = new ArrayList<IVirtualReference>(); |
| dynamicRefs.addAll(Arrays.asList(parentEarManifestReferences)); |
| if (findFuzzyEARRefs) |
| dynamicRefs.addAll(Arrays.asList(fuzzyEarManifestReferences)); |
| |
| for (Iterator<IVirtualReference> iterator = dynamicRefs.iterator(); iterator.hasNext();) { |
| IVirtualReference reference = iterator.next(); |
| IVirtualComponent dynamicComponent = reference.getReferencedComponent(); |
| boolean shouldInclude = true; |
| for(IVirtualReference hardRef : getHardReferences()){ |
| if(hardRef.getReferencedComponent().equals(dynamicComponent)){ |
| shouldInclude = false; |
| break; |
| } |
| } |
| if (shouldInclude) { |
| all.add(reference); |
| } |
| } |
| IVirtualReference[] refs = all.toArray(new IVirtualReference[all.size()]); |
| VirtualReferenceUtilities.INSTANCE.ensureReferencesHaveNames(refs); |
| |
| if (getExpandRefs) { |
| return JavaEEProjectUtilities.getExpandedReferences(this, refs); |
| } |
| return refs; |
| } |
| |
| @Override |
| public IVirtualReference[] getReferences() { |
| return getReferences(true, false); |
| } |
| |
| public IVirtualReference[] getReferences(final boolean getJavaRefs, final boolean findFuzzyEARRefs) { |
| Map<String, Object> options = new HashMap<String, Object>(); |
| options.put(GET_JAVA_REFS, new Boolean(getJavaRefs)); |
| options.put(GET_FUZZY_EAR_REFS, new Boolean(findFuzzyEARRefs)); |
| return getReferences(options); |
| } |
| |
| /** |
| * Non-manifest references are hard references *OR* java classpath |
| * references |
| * |
| * @return |
| */ |
| public IVirtualReference[] getNonManifestReferences() { |
| Map<String, Object> options = new HashMap<String, Object>(); |
| options.put(IVirtualComponent.REQUESTED_REFERENCE_TYPE, IVirtualComponent.FLATTENABLE_REFERENCES); |
| return getReferences(options); |
| } |
| |
| @Deprecated |
| public IVirtualReference[] getNonManifestReferences(final boolean getJavaRefs) { |
| Map<String, Object> options = new HashMap<String, Object>(); |
| options.put(IVirtualComponent.REQUESTED_REFERENCE_TYPE, IVirtualComponent.FLATTENABLE_REFERENCES); |
| options.put(GET_JAVA_REFS, new Boolean(getJavaRefs)); |
| return getReferences(options); |
| } |
| |
| private IVirtualReference[] getNonManifestRefs(final boolean getJavaRefs) { |
| ArrayList<IVirtualReference> allRefs = new ArrayList<IVirtualReference>(); |
| IVirtualReference[] hardRefs = getHardReferences(); |
| allRefs.addAll(Arrays.asList(hardRefs)); |
| if (getJavaRefs) |
| allRefs.addAll(Arrays.asList(getJavaClasspathReferences(hardRefs))); |
| return allRefs.toArray(new IVirtualReference[allRefs.size()]); |
| } |
| |
| public static String[] getManifestClasspath( |
| IVirtualComponent moduleComponent) { |
| return ManifestUtilities.getManifestClasspath(moduleComponent, |
| new Path(J2EEConstants.MANIFEST_URI)); |
| } |
| |
| public IVirtualReference[] getJavaClasspathReferences( |
| IVirtualReference[] hardReferences) { |
| final boolean isLegacyJ2EE = JavaEEProjectUtilities.isLegacyJ2EEComponent(this); |
| final boolean isWebApp = JavaEEProjectUtilities.isDynamicWebComponent(this); |
| |
| final IProject project = getProject(); |
| final List cpRefs = new ArrayList(); |
| |
| try { |
| if (project == null || !project.isAccessible() |
| || !project.hasNature(JavaCoreLite.NATURE_ID)) { |
| return new IVirtualReference[0]; |
| } |
| |
| final IJavaProjectLite javaProjectLite = JavaCoreLite.create(project); |
| if (javaProjectLite == null) |
| return new IVirtualReference[0]; |
| |
| // retrieve all referenced classpath entries |
| final Map referencedEntries = ClasspathDependencyUtil |
| .getComponentClasspathDependencies(javaProjectLite,isLegacyJ2EE); |
| |
| if (referencedEntries.isEmpty()) |
| return new IVirtualReference[0]; |
| |
| IVirtualReference[] innerHardReferences = hardReferences == null ? |
| getHardReferences() : hardReferences; |
| final IPath[] hardRefPaths = new IPath[innerHardReferences.length]; |
| for (int j = 0; j < innerHardReferences.length; j++) { |
| final IVirtualComponent comp = innerHardReferences[j].getReferencedComponent(); |
| if (comp.isBinary()) { |
| hardRefPaths[j] = (IPath)comp.getAdapter(IPath.class); |
| } |
| } |
| |
| IContainer[] mappedClassFolders = null; |
| final Iterator i = referencedEntries.keySet().iterator(); |
| while (i.hasNext()) { |
| final IClasspathEntry entry = (IClasspathEntry) i.next(); |
| final IClasspathAttribute attrib = (IClasspathAttribute) referencedEntries |
| .get(entry); |
| final boolean isClassFolder = ClasspathDependencyUtil.isClassFolderEntry(entry); |
| final IPath runtimePath = ClasspathDependencyUtil.getRuntimePath(attrib, isWebApp, isClassFolder); |
| boolean add = true; |
| final IPath entryLocation = ClasspathDependencyUtil.getEntryLocation(entry); |
| if (entryLocation == null) { |
| // unable to retrieve location for cp entry, do not |
| // contribute as a virtual ref |
| add = false; |
| } else if (!isClassFolder) { // check hard archive refs |
| for (int j = 0; j < hardRefPaths.length; j++) { |
| if (entryLocation.equals(hardRefPaths[j])) { |
| // entry resolves to same file as existing hard |
| // reference, can skip |
| add = false; |
| break; |
| } |
| } |
| } else { // check class folders mapped in component file as |
| // class folders associated with mapped src folders |
| if (mappedClassFolders == null) { |
| List<IContainer> containers = JavaLiteUtilities |
| .getJavaOutputContainers(this); |
| mappedClassFolders = containers |
| .toArray(new IContainer[containers.size()]); |
| } |
| for (int j = 0; j < mappedClassFolders.length; j++) { |
| if (entryLocation.equals(mappedClassFolders[j] |
| .getFullPath())) { |
| // entry resolves to same file as existing class |
| // folder mapping, skip |
| add = false; |
| break; |
| } |
| } |
| } |
| |
| if (add && entryLocation != null) { |
| final IVirtualReference entryReference; |
| String componentPath = null; |
| |
| if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) |
| { |
| final IProject cpEntryProject = ResourcesPlugin.getWorkspace().getRoot().getProject(entry.getPath().lastSegment()); |
| IVirtualComponent entryComponent = ComponentCore.createComponent(cpEntryProject); |
| entryReference = ComponentCore.createReference(this, entryComponent, runtimePath); |
| entryReference.setArchiveName(VirtualReferenceUtilities.INSTANCE.getDefaultProjectArchiveName(entryComponent)); |
| } else { |
| componentPath = VirtualArchiveComponent.CLASSPATHARCHIVETYPE + IPath.SEPARATOR + entryLocation.toPortableString(); |
| ClasspathDependencyVirtualComponent entryComponent = new ClasspathDependencyVirtualComponent(project, componentPath, isClassFolder); |
| entryReference = ComponentCore.createReference(this, entryComponent, runtimePath); |
| ((VirtualReference) entryReference).setDerived(true); |
| entryReference.setArchiveName(ClasspathDependencyUtil.getArchiveName(entry)); |
| } |
| cpRefs.add(entryReference); |
| } |
| } |
| |
| } catch (CoreException jme) { |
| J2EEPlugin.logError(jme); |
| } |
| |
| return (IVirtualReference[]) cpRefs.toArray(new IVirtualReference[cpRefs.size()]); |
| } |
| |
| private void cacheManifestReferences() { |
| if (parentEarManifestReferences == null |
| || fuzzyEarManifestReferences == null) { |
| IVirtualReference[][] refs = calculateManifestReferences(this, true); |
| parentEarManifestReferences = refs[0]; |
| fuzzyEarManifestReferences = refs[1]; |
| } |
| } |
| |
| private static IVirtualReference[][] calculateManifestReferences( |
| IVirtualComponent moduleComponent, boolean checkFuzzyRefs) { |
| String[] manifestClasspath = getManifestClasspath(moduleComponent); |
| IProject[] earProjects = EarUtilities |
| .getReferencingEARProjects(moduleComponent.getProject()); |
| // Early aborts |
| if (manifestClasspath == null || manifestClasspath.length == 0 |
| || earProjects.length == 0) { |
| return new IVirtualReference[][] { new IVirtualReference[0], new IVirtualReference[0] }; |
| } |
| |
| // Get our found cache going |
| boolean[] foundRefAlready = new boolean[manifestClasspath.length]; |
| for (int i = 0; i < foundRefAlready.length; i++) |
| foundRefAlready[i] = false; |
| |
| // Get the true parent references |
| IProject firstEar = earProjects[earProjects.length - 1]; |
| ArrayList<IVirtualReference> tmp = cacheOneEarProjectManifestRefs( |
| moduleComponent, firstEar, manifestClasspath, foundRefAlready); |
| IVirtualReference[] parentEarManifestReferences = tmp |
| .toArray(new IVirtualReference[tmp.size()]); |
| |
| ArrayList<IVirtualReference> dynamicReferences = new ArrayList<IVirtualReference>(); |
| // get the fuzzy references |
| if (checkFuzzyRefs) { |
| if (earProjects.length > 1) { |
| for (int earIndex = earProjects.length - 2; earIndex > -1; earIndex--) { |
| tmp = cacheOneEarProjectManifestRefs(moduleComponent, |
| firstEar, manifestClasspath, foundRefAlready); |
| dynamicReferences.addAll(tmp); |
| } |
| } |
| } |
| IVirtualReference[] fuzzyEarManifestReferences = dynamicReferences |
| .toArray(new IVirtualReference[dynamicReferences.size()]); |
| |
| // return our two creatures |
| return new IVirtualReference[][] { parentEarManifestReferences, |
| fuzzyEarManifestReferences }; |
| } |
| |
| protected static ArrayList<IVirtualReference> cacheOneEarProjectManifestRefs( |
| IVirtualComponent moduleComponent, IProject earProject, |
| String[] manifestClasspath, boolean[] foundRefAlready) { |
| ArrayList<IVirtualReference> dynamicReferences = new ArrayList<IVirtualReference>(); |
| |
| IVirtualReference foundRef = null; |
| String earArchiveURI = null; // The URI for this archive in the EAR |
| boolean simplePath = false; |
| IVirtualReference[] earRefs = null; |
| IVirtualComponent tempEARComponent = ComponentCore |
| .createComponent(earProject); |
| IVirtualReference[] tempEarRefs = tempEARComponent.getReferences(); |
| for (int j = 0; j < tempEarRefs.length && earRefs == null; j++) { |
| if (tempEarRefs[j].getReferencedComponent().equals(moduleComponent)) { |
| earRefs = tempEarRefs; |
| foundRef = tempEarRefs[j]; |
| earArchiveURI = foundRef.getArchiveName(); |
| simplePath = earArchiveURI != null ? earArchiveURI |
| .lastIndexOf("/") == -1 : true; //$NON-NLS-1$ |
| } |
| } |
| if (null != earRefs) { |
| for (int manifestIndex = 0; manifestIndex < manifestClasspath.length; manifestIndex++) { |
| boolean found = false; |
| if (foundRefAlready != null && foundRefAlready[manifestIndex]) { |
| continue; |
| } |
| for (int j = 0; j < earRefs.length && !found; j++) { |
| if (foundRef != earRefs[j]) { |
| String archiveName = earRefs[j].getArchiveName(); |
| if (null != archiveName) { |
| boolean shouldAdd = false; |
| String manifestEntryString = manifestClasspath[manifestIndex]; |
| if (manifestEntryString != null) { |
| IPath manifestPath = new Path(manifestEntryString); |
| manifestEntryString = manifestPath |
| .toPortableString(); |
| } |
| |
| if (simplePath && manifestEntryString != null |
| && manifestEntryString.lastIndexOf("/") == -1) { //$NON-NLS-1$ |
| shouldAdd = archiveName.equals(manifestEntryString); |
| } else { |
| String earRelativeURI = ArchiveUtil |
| .deriveEARRelativeURI(manifestEntryString, |
| earArchiveURI); |
| if (null != earRelativeURI) { |
| IPath earRefPath = earRefs[j].getRuntimePath().makeRelative(); |
| shouldAdd = earRelativeURI.equals(earRefPath.append(archiveName).toString()); |
| } |
| } |
| |
| if (shouldAdd) { |
| if (foundRefAlready != null) { |
| foundRefAlready[manifestIndex] = true; |
| } |
| found = true; |
| IVirtualComponent dynamicComponent = earRefs[j].getReferencedComponent(); |
| IVirtualReference dynamicReference = ComponentCore.createReference(moduleComponent,dynamicComponent); |
| ((VirtualReference) dynamicReference).setDerived(true); |
| dynamicReferences.add(dynamicReference); |
| } |
| } |
| } |
| } |
| } |
| } |
| return dynamicReferences; |
| } |
| |
| public static List getManifestReferences(IVirtualComponent moduleComponent, |
| IVirtualReference[] hardReferences) { |
| return getManifestReferences(moduleComponent, hardReferences, false); |
| } |
| |
| public static List getManifestReferences(IVirtualComponent moduleComponent, |
| IVirtualReference[] hardReferences, boolean findFuzzyEARRefs) { |
| IVirtualReference[][] refs = calculateManifestReferences( |
| moduleComponent, findFuzzyEARRefs); |
| ArrayList<IVirtualReference> tmp = new ArrayList<IVirtualReference>(); |
| tmp.addAll(Arrays.asList(refs[0])); |
| if (findFuzzyEARRefs) |
| tmp.addAll(Arrays.asList(refs[1])); |
| return tmp; |
| } |
| |
| private boolean checkIfStillValid() { |
| boolean valid = IDependencyGraph.INSTANCE.getModStamp() == depGraphModStamp; |
| valid = valid && J2EEDependencyListener.INSTANCE.getModStamp() == jeeModStamp; |
| if (!valid) { |
| clearCache(); |
| } |
| return valid; |
| } |
| |
| @Override |
| protected void clearCache() { |
| super.clearCache(); |
| depGraphModStamp = IDependencyGraph.INSTANCE.getModStamp(); |
| jeeModStamp = J2EEDependencyListener.INSTANCE.getModStamp(); |
| hardReferences = null; |
| javaReferences = null; |
| parentEarManifestReferences = null; |
| fuzzyEarManifestReferences = null; |
| } |
| |
| public boolean canReceiveClasspathDependencies() { |
| return J2EEProjectUtilities.isDynamicWebProject(getProject()); |
| } |
| |
| public IPath getClasspathFolderPath(IClasspathDependencyComponent component) { |
| if( J2EEProjectUtilities.isDynamicWebProject(getProject())) { |
| return new Path(J2EEConstants.WEB_INF_LIB).makeAbsolute(); |
| } |
| return new Path("/"); //$NON-NLS-1$ |
| } |
| |
| public static void setDefaultDeploymentDescriptorFolder(IVirtualFolder folder, IPath aProjectRelativeLocation, IProgressMonitor monitor) { |
| if (folder instanceof ITaggedVirtualResource){ |
| ITaggedVirtualResource taggedFolder = (ITaggedVirtualResource)folder; |
| //First, remove tag is there is already one folder already tagged |
| IPath[] paths = taggedFolder.getTaggedResources(DD_FOLDER_TAG); |
| for (IPath path:paths){ |
| taggedFolder.tagResource(path, null, monitor); |
| } |
| // Now, tag the correct path |
| ((ITaggedVirtualResource)folder).tagResource(aProjectRelativeLocation, DD_FOLDER_TAG, monitor); |
| } |
| } |
| |
| public static IPath getDefaultDeploymentDescriptorFolder(IVirtualFolder folder) { |
| IPath returnValue = null; |
| if (folder instanceof ITaggedVirtualResource){ |
| returnValue = ((ITaggedVirtualResource)folder).getFirstTaggedResource(DD_FOLDER_TAG); |
| } |
| return returnValue; |
| } |
| |
| } |