| /******************************************************************************* |
| * Copyright (c) 2005 BEA Systems, Inc. |
| * 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: |
| * rfrost@bea.com - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.jst.j2ee.refactor.operations; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.Set; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin; |
| import org.eclipse.jst.j2ee.model.IEARModelProvider; |
| import org.eclipse.jst.j2ee.model.ModelProviderManager; |
| import org.eclipse.wst.common.componentcore.ComponentCore; |
| import org.eclipse.wst.common.componentcore.ModuleCoreNature; |
| import org.eclipse.wst.common.componentcore.internal.resources.VirtualComponent; |
| import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants; |
| import org.eclipse.wst.common.componentcore.resources.IVirtualComponent; |
| import org.eclipse.wst.common.componentcore.resources.IVirtualFolder; |
| import org.eclipse.wst.common.componentcore.resources.IVirtualReference; |
| import org.eclipse.wst.common.project.facet.core.IFacetedProject; |
| import org.eclipse.wst.common.project.facet.core.IProjectFacet; |
| import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion; |
| import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager; |
| import org.eclipse.wst.server.core.IModule; |
| import org.eclipse.wst.server.core.IServer; |
| import org.eclipse.wst.server.core.ServerUtil; |
| |
| /** |
| * IDataModel object property stored under the property name |
| * {@link ProjectRefactoringDataModelProvider#PROJECT_METADATA}. |
| * |
| * Note: this class is not multi-thread safe. |
| */ |
| public class ProjectRefactorMetadata { |
| |
| public static int NON_CACHING = 0; |
| public static int REF_CACHING = 1; |
| public static int REFERER_CACHING = 2; |
| |
| private int _virtualCompCaching = NON_CACHING; |
| private final IProject _project; |
| private Map<IModule, IServer[]> serverMap; |
| private IVirtualComponent virtualComp = null; |
| private final List dependentMetadata = new ArrayList(); |
| private boolean javaNature; |
| private boolean moduleCoreNature; |
| private IModule[] modules; |
| private Set facets = new HashSet(); |
| private final Map earToModuleURI = new HashMap(); |
| |
| public ProjectRefactorMetadata(final IProject project) { |
| _project = project; |
| } |
| |
| public ProjectRefactorMetadata(final IProject project, final int virtualCompCaching) { |
| this(project); |
| _virtualCompCaching = virtualCompCaching; |
| } |
| |
| public void computeMetadata() { |
| computeMetadata(_project); |
| } |
| public void computeMetadata(final IProject oldProject) { |
| try { |
| javaNature = _project.hasNature("org.eclipse.jdt.core.javanature"); //$NON-NLS-1$ |
| moduleCoreNature = ModuleCoreNature.isFlexibleProject(_project); |
| if (moduleCoreNature) { |
| if (_virtualCompCaching == REF_CACHING) { |
| virtualComp = new RefCachingVirtualComponent(ComponentCore.createComponent(_project)); |
| } else if (_virtualCompCaching == REFERER_CACHING) { |
| virtualComp = new RefererCachingVirtualComponent(ComponentCore.createComponent(_project)); |
| } else { |
| virtualComp = ComponentCore.createComponent(_project); |
| } |
| final IFacetedProject facetedProject = ProjectFacetsManager.create(_project); |
| modules = ServerUtil.getModules(_project); |
| // XXX Due to resource change listener order uncertainty, the project associated with the |
| // module may be either the new (correct) project or the old project so need to try both |
| if ((modules == null || modules.length == 0 )&& !_project.equals(oldProject)) { |
| modules = ServerUtil.getModules(oldProject); |
| } |
| if( modules == null ) |
| modules = new IModule[]{}; |
| |
| if (facetedProject != null) { |
| facets = facetedProject.getProjectFacets(); |
| } |
| } |
| } catch (CoreException ce) { |
| J2EEPlugin.logError(ce); |
| } |
| } |
| |
| public void computeServers() { |
| serverMap = new HashMap<IModule, IServer[]>(); |
| for( int i = 0; i < modules.length; i++ ) { |
| serverMap.put(modules[i],ServerUtil.getServersByModule(modules[i], null)); |
| } |
| } |
| |
| /** |
| * This will get the servers for the first module of the project |
| */ |
| @Deprecated |
| public IServer[] getServers() { |
| if( modules == null || modules.length == 0 ) |
| return new IServer[]{}; |
| return serverMap.get(modules[0]) == null ? new IServer[]{} : serverMap.get(modules[0]); |
| } |
| |
| /** |
| * Get the list of servers this module is on |
| * @param module |
| * @return |
| */ |
| public IServer[] getServers(IModule module) { |
| return serverMap.get(module) == null ? new IServer[]{} : serverMap.get(module); |
| } |
| |
| public void computeDependentMetadata(final int virtualComponentCaching, final IProject[] dependentProjects) { |
| // get all referencing projects and execute the appropriate update operation for each one |
| ProjectRefactorMetadata metadata; |
| for (int i = 0; i < dependentProjects.length; i++) { |
| final IProject dependentProject = dependentProjects[i]; |
| if (dependentProject.exists() && dependentProject.isOpen()) { |
| metadata = new ProjectRefactorMetadata(dependentProjects[i], virtualComponentCaching); |
| metadata.computeMetadata(); |
| dependentMetadata.add(metadata); |
| if (metadata.isEAR() && virtualComp.getComponent() != null) { |
| final String uri = getModuleURI(dependentProject, virtualComp); |
| if (uri != null) { |
| earToModuleURI.put(dependentProject.getName(), uri); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * If this project is associated with the specified EAR project, retrieves the module URI for the dependency or null if |
| * it could not be retrieved. |
| * @param earName Name of the EAR project. |
| * @return Module URI for the project in the context of that EAR. |
| */ |
| public String getModuleURI(final String earName) { |
| return (String) earToModuleURI.get(earName); |
| } |
| |
| private String getModuleURI(final IProject earProject, final IVirtualComponent comp) { |
| IEARModelProvider earModelProvider = null; |
| earModelProvider = (IEARModelProvider) ModelProviderManager.getModelProvider(earProject); |
| if (earModelProvider != null) { |
| return earModelProvider.getModuleURI(comp); |
| } |
| return null; |
| } |
| |
| /** |
| * Retrieves the IProject that represents the referenced project. |
| */ |
| public IProject getProject() { |
| return _project; |
| } |
| |
| /** |
| * Retrieves the IModule for the project, or null if no IModule representation |
| * exists. |
| */ |
| @Deprecated |
| public IModule getModule() { |
| return modules == null || modules.length == 0 ? null : modules[0]; |
| } |
| |
| /** |
| * Get all modules in this project |
| * @return |
| */ |
| public IModule[] getModules() { |
| return modules; |
| } |
| |
| /** |
| * Retrieves the project name. |
| */ |
| public String getProjectName() { |
| return _project.getName(); |
| } |
| |
| /** |
| * Retrieves all ProjectRefactorMetadata for dependent projects. |
| * Will be empty if not computed. |
| */ |
| public ProjectRefactorMetadata[] getDependentMetadata() { |
| return (ProjectRefactorMetadata[]) dependentMetadata.toArray(new ProjectRefactorMetadata[dependentMetadata.size()]); |
| } |
| |
| /** |
| * Returns the IVirtualComponent for the project. |
| */ |
| public IVirtualComponent getVirtualComponent() { |
| return virtualComp; |
| } |
| |
| public boolean hasJavaNature() { |
| return javaNature; |
| } |
| |
| public boolean hasModuleCoreNature() { |
| return moduleCoreNature; |
| } |
| |
| public Set getProjectFacets() { |
| return facets; |
| } |
| |
| public boolean hasFacet(final IProjectFacet facet) { |
| for(Iterator itr = facets.iterator(); itr.hasNext();) { |
| final IProjectFacetVersion fv = (IProjectFacetVersion) itr.next(); |
| |
| if(fv.getProjectFacet() == facet) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| public boolean isEAR() { |
| return hasFacet(ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_EAR_MODULE)); |
| } |
| |
| public boolean isEJB() { |
| return hasFacet(ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_EJB_MODULE)); |
| } |
| |
| public boolean isWeb() { |
| return hasFacet(ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_WEB_MODULE)); |
| } |
| |
| public boolean isAppClient() { |
| return hasFacet(ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_APPCLIENT_MODULE)); |
| } |
| |
| public boolean isConnector() { |
| return hasFacet(ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_CONNECTOR_MODULE)); |
| } |
| |
| public boolean isUtility() { |
| return hasFacet(ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_UTILITY_MODULE)); |
| } |
| |
| public class CachingVirtualComponent implements IVirtualComponent { |
| protected final IVirtualComponent _comp; |
| protected boolean _caching = true; |
| public CachingVirtualComponent(final IVirtualComponent comp) { |
| _comp = comp; |
| } |
| public void addReferences(IVirtualReference[] references) { |
| _comp.addReferences(references); |
| } |
| public void create(int updateFlags, IProgressMonitor aMonitor) throws CoreException { |
| _comp.create(updateFlags, aMonitor); |
| } |
| public boolean exists() { |
| return _comp.exists(); |
| } |
| public IVirtualComponent getComponent() { |
| if(_comp == null) return null; |
| return _comp.getComponent(); |
| } |
| public Properties getMetaProperties() { |
| return _comp.getMetaProperties(); |
| } |
| public IPath[] getMetaResources() { |
| return _comp.getMetaResources(); |
| } |
| public String getName() { |
| return _comp.getName(); |
| } |
| public String getDeployedName() { |
| return _comp.getDeployedName(); |
| } |
| public IProject getProject() { |
| return _comp.getProject(); |
| } |
| public IVirtualReference getReference(String aComponentName) { |
| return _comp.getReference(aComponentName); |
| } |
| public IVirtualReference[] getReferences() { |
| return _comp.getReferences(); |
| } |
| public IVirtualReference[] getReferences(Map<String, Object> options) { |
| return _comp.getReferences(options); |
| } |
| public void setCaching(boolean caching) { |
| _caching = caching; |
| } |
| public IVirtualComponent[] getReferencingComponents() { |
| return _comp.getReferencingComponents(); |
| } |
| public IVirtualFolder getRootFolder() { |
| return _comp.getRootFolder(); |
| } |
| public boolean isBinary() { |
| return _comp.isBinary(); |
| } |
| public void setMetaProperties(Properties properties) { |
| _comp.setMetaProperties(properties); |
| } |
| public void setMetaProperty(String name, String value) { |
| _comp.setMetaProperty(name, value); |
| } |
| public void setMetaResources(IPath[] theMetaResourcePaths) { |
| _comp.setMetaResources(theMetaResourcePaths); |
| } |
| public void setReferences(IVirtualReference[] theReferences) { |
| _comp.setReferences(theReferences); |
| } |
| public Object getAdapter(Class adapter) { |
| return _comp.getAdapter(adapter); |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| return _comp.equals(o); |
| } |
| |
| @Override |
| public int hashCode() { |
| return _comp.hashCode(); |
| } |
| |
| @Override |
| public String toString() { |
| return _comp.toString(); |
| } |
| |
| public void removeReference(IVirtualReference aReference) { |
| ((VirtualComponent)_comp).removeReference(aReference); |
| } |
| } |
| |
| public class RefCachingVirtualComponent extends CachingVirtualComponent { |
| private IVirtualReference[] cachedRefs; |
| public RefCachingVirtualComponent(final IVirtualComponent comp) { |
| super(comp); |
| if(comp != null){ |
| cachedRefs = ((VirtualComponent)comp).getAllReferences(); |
| } |
| } |
| |
| @Override |
| public IVirtualReference getReference(String aComponentName) { |
| IVirtualReference[] refs = getReferences(); |
| for (int i = 0; i < refs.length; i++) { |
| IVirtualReference reference = refs[i]; |
| if (reference == null || reference.getReferencedComponent() == null) { |
| return null; |
| } |
| if (reference.getReferencedComponent().getName().equals(aComponentName)) |
| return reference; |
| } |
| return null; |
| } |
| @Override |
| public IVirtualReference[] getReferences() { |
| if (_caching) { |
| return cachedRefs; |
| } |
| return super.getReferences(); |
| } |
| } |
| |
| public class RefererCachingVirtualComponent extends CachingVirtualComponent { |
| private IVirtualComponent[] cachedReferers; |
| public RefererCachingVirtualComponent(final IVirtualComponent comp) { |
| super(comp); |
| if(comp!= null){ |
| cachedReferers = comp.getReferencingComponents(); |
| } |
| } |
| |
| @Override |
| public IVirtualComponent[] getReferencingComponents() { |
| if (_caching) { |
| return cachedReferers; |
| } |
| return _comp.getReferencingComponents(); |
| } |
| } |
| } |