| /******************************************************************************* |
| * 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.componentcore; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.jdt.core.ICompilationUnit; |
| import org.eclipse.jst.common.jdt.internal.integration.JavaArtifactEditModel; |
| import org.eclipse.jst.common.jdt.internal.integration.WorkingCopyManager; |
| import org.eclipse.jst.common.jdt.internal.integration.WorkingCopyProvider; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.Archive; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.OpenFailureException; |
| import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities; |
| import org.eclipse.jst.j2ee.model.IModelProvider; |
| import org.eclipse.jst.j2ee.model.IModelProviderFactory; |
| import org.eclipse.jst.j2ee.model.IModelProviderListener; |
| import org.eclipse.wst.common.componentcore.ArtifactEdit; |
| import org.eclipse.wst.common.componentcore.ModuleCoreNature; |
| import org.eclipse.wst.common.componentcore.internal.ArtifactEditModel; |
| import org.eclipse.wst.common.componentcore.internal.impl.ModuleURIUtil; |
| import org.eclipse.wst.common.componentcore.resources.IVirtualComponent; |
| import org.eclipse.wst.common.internal.emfworkbench.integration.EditModelListener; |
| import org.eclipse.wst.common.project.facet.core.IFacetedProject; |
| import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager; |
| |
| /** |
| * <p> |
| * EnterpriseArtifactEdit obtains a type-specific J2EE metamodel from the managed |
| * {@see org.eclipse.wst.common.modulecore.ArtifactEditModel}. The underlying EditModel maintains |
| * {@see org.eclipse.emf.ecore.resource.Resource}s, such as the J2EE deployment descriptor |
| * resource. The defined methods extract data or manipulate the contents of the underlying resource. |
| * </p> |
| * |
| * <p> |
| * This class is an abstract class, and clients are intended to subclass and own their |
| * implementation. |
| * </p> |
| */ |
| public abstract class EnterpriseArtifactEdit extends ArtifactEdit implements WorkingCopyProvider, IModelProvider, IModelProviderFactory { |
| |
| public static boolean SUPPORT_LEGACY_PROJECTS = true; |
| private ArtifactEdit writableEdit = null; |
| |
| /** |
| * |
| */ |
| protected EnterpriseArtifactEdit() { |
| super(); |
| } |
| |
| public EnterpriseArtifactEdit(IVirtualComponent aModule){ |
| super(aModule); |
| } |
| |
| |
| /** |
| * @param aHandle |
| * @param toAccessAsReadOnly |
| * @throws IllegalArgumentException |
| */ |
| public EnterpriseArtifactEdit(IProject aProject, boolean toAccessAsReadOnly) throws IllegalArgumentException { |
| super(aProject, toAccessAsReadOnly); |
| } |
| |
| /** |
| * @param aHandle |
| * @param toAccessAsReadOnly |
| * @throws IllegalArgumentException |
| */ |
| protected EnterpriseArtifactEdit(IProject aProject, boolean toAccessAsReadOnly, boolean forCreate, String projectType) throws IllegalArgumentException { |
| super(aProject, toAccessAsReadOnly, forCreate, projectType); |
| } |
| |
| /** |
| * <p> |
| * Creates an instance facade for the given {@see ArtifactEditModel}. |
| * </p> |
| * <p> |
| * Clients that use this constructor are required to release their access of the EditModel when |
| * finished. Calling {@see ArtifactEdit#dispose()}will not touch the supplied EditModel. |
| * </p> |
| * |
| * @param anArtifactEditModel |
| * A valid, properly-accessed EditModel |
| */ |
| public EnterpriseArtifactEdit(ArtifactEditModel model) { |
| super(model); |
| } |
| |
| /** |
| * <p> |
| * Creates an instance facade for the given {@see WorkbenchComponent}. |
| * </p> |
| * <p> |
| * Instances of EnterpriseArtifactEdit that are returned through this method must be |
| * {@see #dispose()}ed of when no longer in use. |
| * </p> |
| * <p> |
| * Note: This method is for internal use only. Clients should not call this method. |
| * </p> |
| * |
| * @param aNature |
| * A non-null {@see ModuleCoreNature} for an accessible project |
| * @param aModule |
| * A non-null {@see WorkbenchComponent} pointing to a module from the given |
| * {@see ModuleCoreNature} |
| */ |
| |
| protected EnterpriseArtifactEdit(ModuleCoreNature aNature, IVirtualComponent aModule, boolean toAccessAsReadOnly) { |
| super(aNature, aModule, toAccessAsReadOnly); |
| } |
| |
| /** |
| * <p> |
| * Retrieves J2EE version information from deployment descriptor resource. |
| * </p> |
| * |
| * @return An the J2EE Specification version of the underlying {@see WorkbenchComponent} |
| * |
| */ |
| public abstract int getJ2EEVersion(); |
| |
| /** |
| * <p> |
| * Retrieves a deployment descriptor resource from {@see ArtifactEditModel}using a defined URI. |
| * </p> |
| * |
| * @return The correct deployment descriptor resource for the underlying |
| * {@see WorkbenchComponent} |
| * |
| */ |
| public abstract Resource getDeploymentDescriptorResource(); |
| |
| /** |
| * <p> |
| * Obtains the root object from a deployment descriptor resource, the root object contains all |
| * other resource defined objects. Examples of a deployment descriptor root include: |
| * {@see org.eclipse.jst.j2ee.webapplication.WebApp}, |
| * {@see org.eclipse.jst.j2ee.application.Application}, and |
| * {@see org.eclipse.jst.j2ee.ejb.EJBJar} |
| * </p> |
| * <p> |
| * Subclasses may extend this method to perform their own deployment descriptor creataion/ |
| * retrieval. |
| * </p> |
| * |
| * @return An EMF metamodel object representing the J2EE deployment descriptor |
| * |
| */ |
| |
| public EObject getDeploymentDescriptorRoot() { |
| Resource res = getDeploymentDescriptorResource(); |
| if (!res.getContents().isEmpty()) |
| return (EObject) res.getContents().get(0); |
| return null; |
| } |
| |
| /** |
| * Returns a working copy managet |
| * |
| * @return |
| */ |
| |
| public WorkingCopyManager getWorkingCopyManager() { |
| if(isBinary()){ |
| throwAttemptedBinaryEditModelAccess(); |
| } |
| return ((JavaArtifactEditModel)getArtifactEditModel()).getWorkingCopyManager(); |
| } |
| |
| /** |
| * Returns the working copy remembered for the compilation unit. |
| * |
| * @param input |
| * ICompilationUnit |
| * @return the working copy of the compilation unit, or <code>null</code> if there is no |
| * remembered working copy for this compilation unit |
| */ |
| public ICompilationUnit getWorkingCopy(ICompilationUnit cu, boolean forNewCU) throws org.eclipse.core.runtime.CoreException { |
| if (isReadOnly()) |
| return null; |
| return getWorkingCopyManager().getWorkingCopy(cu, forNewCU); |
| } |
| protected boolean validProjectVersion(IProject project) { |
| |
| return EnterpriseArtifactEdit.SUPPORT_LEGACY_PROJECTS || primValidProjectVersion(project); |
| } |
| protected boolean primValidProjectVersion(IProject project) { |
| |
| // Return true if project is being created |
| if (!project.exists()) return true; |
| IFacetedProject facetedProject = null; |
| try { |
| facetedProject = ProjectFacetsManager.create(project); |
| } catch (CoreException e) { |
| // Do Nothing |
| } |
| if (facetedProject == null) |
| // Return true if project facet is being created |
| return true; |
| //return true for legacy projects, or use preference. |
| return !J2EEProjectUtilities.isJEEProject(project); |
| } |
| |
| /** |
| * Returns the working copy remembered for the compilation unit encoded in the given editor |
| * input. Does not connect the edit model to the working copy. |
| * |
| * @param input |
| * ICompilationUnit |
| * @return the working copy of the compilation unit, or <code>null</code> if the input does |
| * not encode an editor input, or if there is no remembered working copy for this |
| * compilation unit |
| */ |
| public ICompilationUnit getExistingWorkingCopy(ICompilationUnit cu) throws org.eclipse.core.runtime.CoreException { |
| return getWorkingCopyManager().getExistingWorkingCopy(cu); |
| } |
| |
| public URI getModuleLocation(String moduleName) { |
| if (getProject()!=null) |
| return ModuleURIUtil.fullyQualifyURI(getProject()); |
| return null; |
| } |
| |
| /** |
| * This will delete |
| * |
| * @cu from the workbench and fix the internal references for this working copy manager. |
| */ |
| public void delete(org.eclipse.jdt.core.ICompilationUnit cu, org.eclipse.core.runtime.IProgressMonitor monitor) { |
| getWorkingCopyManager().delete(cu, monitor); |
| } |
| |
| /** |
| * <p> |
| * Create an deployment descriptor resource if one does not get and return it. Subclasses should |
| * overwrite this method to create their own type of deployment descriptor |
| * </p> |
| * |
| * @return an EObject |
| */ |
| |
| public abstract EObject createModelRoot(); |
| |
| /** |
| * <p> |
| * Create an deployment descriptor resource if one does not get and return it. Subclasses should |
| * overwrite this method to create their own type of deployment descriptor |
| * </p> |
| * |
| * @param int |
| * version of the component |
| * @return an EObject |
| */ |
| |
| public abstract EObject createModelRoot(int version); |
| |
| public Archive asArchive(boolean includeSource) throws OpenFailureException{ |
| return asArchive(includeSource, true); |
| } |
| |
| public Archive asArchive(boolean includeSource, boolean includeClasspathComponents) throws OpenFailureException { |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jst.j2ee.model.IModelProvider#getModelObject() |
| */ |
| public Object getModelObject() { |
| if ( getWritableEdit() != null) |
| return getWritableEdit().getContentModelRoot(); |
| return getContentModelRoot(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jst.j2ee.model.IModelProvider#getModelObject(org.eclipse.core.runtime.IPath) |
| */ |
| public Object getModelObject(IPath modelPath) { |
| if ( getWritableEdit() != null) { |
| Resource res = ((ArtifactEditModel)getWritableEdit().getAdapter(ArtifactEditModel.ADAPTER_TYPE)).getResource(URI.createURI(modelPath.toString())); |
| if (res != null && !res.getContents().isEmpty()) |
| return res.getContents().get(0); |
| else return null; |
| } |
| return getContentModelRoot(); |
| } |
| |
| public IModelProvider create(IProject project) { |
| return (IModelProvider)getArtifactEditForRead(project); |
| } |
| |
| public IModelProvider create(IVirtualComponent component) { |
| return (IModelProvider)getArtifactEditForRead(component); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jst.j2ee.model.IModelProvider#modify(java.lang.Runnable, org.eclipse.core.runtime.IPath) |
| */ |
| public void modify(Runnable runnable, IPath modelPath) { |
| //About to modify and save this model |
| |
| // access model (write count) |
| // cache writable model (setWriteableEdit()) |
| // run runnable |
| // save model |
| // release access count |
| // null Writable Edit |
| |
| } |
| |
| public IStatus validateEdit(IPath modelPath, Object context) { |
| // ArtifactEdit will validate all files it manages, and uses its own context mechanism |
| return validateEdit(); |
| } |
| |
| /** |
| * @param writableEdit the writableEdit to set |
| */ |
| protected void setWritableEdit(ArtifactEdit writableEdit) { |
| this.writableEdit = writableEdit; |
| } |
| |
| /** |
| * @return the writableEdit |
| */ |
| protected ArtifactEdit getWritableEdit() { |
| return writableEdit; |
| } |
| |
| public void addListener(IModelProviderListener listener) |
| { |
| if (listener instanceof EditModelListener) |
| { |
| addListener((EditModelListener)listener); |
| } |
| } |
| |
| public void removeListener(IModelProviderListener listener) |
| { |
| if (listener instanceof EditModelListener) |
| { |
| removeListener((EditModelListener)listener); |
| } |
| } |
| } |