/*******************************************************************************
* Copyright (c) 2003, 2006 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.common.jdt.internal.integration;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jem.util.logger.proxy.Logger;
import org.eclipse.jst.common.frameworks.CommonFrameworksPlugin;
import org.eclipse.wst.common.frameworks.internal.ISaveHandler;
import org.eclipse.wst.common.frameworks.internal.SaveFailedException;
import org.eclipse.wst.common.frameworks.internal.SaveHandlerHeadless;
import org.eclipse.wst.common.frameworks.internal.SaveHandlerRegister;
import org.eclipse.wst.common.frameworks.internal.plugin.WTPCommonPlugin;
/**
* Insert the type's description here. Creation date: (4/27/2001 4:14:30 PM)
*
* @author: Administrator
*/
public class WTPWorkingCopyManager implements WorkingCopyManager {
//New CUs that will need to be deleted upon dispose
private List originalNewCompilationUnits;
//New CUs that were created that need saved immediately (after each gen)
private List needsSavingCompilationUnits;
//A complete list of new CUs that is only cleared on save and dispose
private List newCompilationUnits;
private HashMap deletedCompilationUnits;
protected static final Class IRESOURCE_CLASS = IResource.class;
/**
* WTPWorkingCopyManager constructor comment.
*/
public WTPWorkingCopyManager() {
super();
}
protected void addDeletedCompilationUnit(ICompilationUnit cu) {
getNeedsSavingCompilationUnits().remove(cu);
if (!getOriginalNewCompilationUnits().contains(cu) && !getDeletedCompilationUnits().containsKey(cu))
primAddDeletedCompilationUnit(cu);
getOriginalNewCompilationUnits().remove(cu);
}
protected void addNewCompilationUnit(ICompilationUnit cu, ICompilationUnit workingCopy) {
getNewCompilationUnits().add(cu);
getNeedsSavingCompilationUnits().add(workingCopy);
if (!getDeletedCompilationUnits().containsKey(cu))
getOriginalNewCompilationUnits().add(cu);
}
/**
* This will save all of the new CompilationUnits to be saved.
*/
protected void commitWorkingCopy(ICompilationUnit wc, IProgressMonitor monitor) {
try {
try {
wc.commitWorkingCopy(false, monitor);
} catch (JavaModelException e) {
if (isFailedWriteFileFailure(e) && shouldSaveReadOnly(wc))
wc.commitWorkingCopy(false, monitor);
else
throw e;
}
} catch (JavaModelException e) {
org.eclipse.jem.util.logger.proxy.Logger.getLogger().logError(e);
throw new SaveFailedException(e);
} finally {
try {
wc.discardWorkingCopy();
} catch (JavaModelException e1) {
org.eclipse.jem.util.logger.proxy.Logger.getLogger().logError(e1);
throw new SaveFailedException(e1);
}
}
}
/**
* This will delete
*
* @cu from the workbench and fix the internal references for this working copy manager.
*/
public void delete(final ICompilationUnit cu, final IProgressMonitor monitor) {
ICompilationUnit localCU = cu;
if (localCU.isWorkingCopy())
localCU = localCU.getPrimary();
addDeletedCompilationUnit(localCU);
try {
localCU.delete(false, monitor);
} catch (JavaModelException e) {
if (e.getStatus().getCode() != org.eclipse.jdt.core.IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST)
org.eclipse.jem.util.logger.proxy.Logger.getLogger().logError(e);
}
}
protected void discardOriginalNewCompilationUnits() {
if (getOriginalNewCompilationUnits().isEmpty())
return;
List cus = getOriginalNewCompilationUnits();
ICompilationUnit cu;
ICompilationUnit wc = null;
for (int i = 0; i < cus.size(); i++) {
cu = (ICompilationUnit) cus.get(i);
if (cu.isWorkingCopy()) {
wc = cu;
cu = wc.getPrimary();
}
primDelete(cu);
if (wc != null)
try {
wc.discardWorkingCopy();
} catch (JavaModelException e) {
Logger.getLogger().logError(e);
}
}
}
public void dispose() {
IWorkspaceRunnable runnable = new IWorkspaceRunnable() {
public void run(IProgressMonitor aMonitor) {
primDispose();
}
};
try {
if (!WTPCommonPlugin.getWorkspace().isTreeLocked()) {
WTPCommonPlugin.getWorkspace().run(runnable,null, IWorkspace.AVOID_UPDATE,null);
} else {
runnable.run(null);
}
} catch (CoreException e) {
CommonFrameworksPlugin.logError(e);
}
}
public void revert() {
IWorkspaceRunnable runnable = new IWorkspaceRunnable() {
public void run(IProgressMonitor aMonitor) {
primRevert();
}
};
runOperation(runnable, null, true);
}
public Set getAffectedFiles() {
return Collections.EMPTY_SET;
}
/**
* Insert the method's description here. Creation date: (7/11/2001 6:43:37 PM)
*
* @return java.util.HashMap
*/
protected HashMap getDeletedCompilationUnits() {
if (deletedCompilationUnits == null)
deletedCompilationUnits = new HashMap();
return deletedCompilationUnits;
}
/**
* 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 org.eclipse.jdt.core.ICompilationUnit getExistingWorkingCopy(ICompilationUnit cu) throws CoreException {
ICompilationUnit newCU = getNewCompilationUnitWorkingCopy(cu);
if (newCU != null)
return newCU;
return null;
}
/**
* Insert the method's description here. Creation date: (7/19/2001 11:00:19 AM)
*
* @return java.util.List
*/
protected java.util.List getNeedsSavingCompilationUnits() {
if (needsSavingCompilationUnits == null)
needsSavingCompilationUnits = new ArrayList();
return needsSavingCompilationUnits;
}
/**
* Insert the method's description here. Creation date: (4/26/2001 3:49:05 PM)
*
* @return java.util.List
*/
protected java.util.List getNewCompilationUnits() {
if (newCompilationUnits == null)
newCompilationUnits = new ArrayList();
return newCompilationUnits;
}
/**
* It is possible that we have already created this CompilationUnit and its working copy. If
* this is the case, return our new working copy and do not create a new one.
*/
protected ICompilationUnit getNewCompilationUnitWorkingCopy(ICompilationUnit cu) {
if (hasNewCompilationUnit(cu)) {
List list = getNeedsSavingCompilationUnits();
ICompilationUnit copy;
for (int i = 0; i < list.size(); i++) {
copy = (ICompilationUnit) list.get(i);
if (cu.equals(copy.getPrimary()))
return copy;
}
}
return null;
}
/**
* Insert the method's description here. Creation date: (4/26/2001 3:49:05 PM)
*
* @return java.util.List
*/
protected java.util.List getOriginalNewCompilationUnits() {
if (originalNewCompilationUnits == null)
originalNewCompilationUnits = new ArrayList();
return originalNewCompilationUnits;
}
/**
* Return the IPackageFragment for the given ICompilationUnit.
*/
protected IPackageFragment getPackageFragment(ICompilationUnit cu) {
if (cu == null)
return null;
IJavaElement parent = cu;
int elementType = cu.getElementType();
while (parent != null && elementType != IJavaElement.PACKAGE_FRAGMENT) {
parent = parent.getParent();
if (parent != null)
elementType = parent.getElementType();
else
elementType = -1;
}
return (IPackageFragment) parent;
}
protected ISaveHandler getSaveHandler() {
return SaveHandlerRegister.getSaveHandler();
}
/**
* 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 (cu == null || cu.isWorkingCopy())
return cu;
ICompilationUnit newCU = getNewCompilationUnitWorkingCopy(cu);
if (newCU != null)
return newCU;
ICompilationUnit workingCopy = cu.getWorkingCopy(null);
addNewCompilationUnit(cu, workingCopy);
return workingCopy;
}
/**
* Has a new compilation unit already been created.
*/
protected boolean hasNewCompilationUnit(ICompilationUnit cu) {
return getNewCompilationUnits().contains(cu);
}
protected boolean isFailedWriteFileFailure(Exception ex) {
return SaveHandlerHeadless.isFailedWriteFileFailure(ex);
}
protected void primAddDeletedCompilationUnit(ICompilationUnit cu) {
if (cu == null)
return;
Object[] info = new Object[2];
info[0] = getPackageFragment(cu);
try {
info[1] = cu.getSource();
} catch (JavaModelException e) {
info[1] = null;
}
getDeletedCompilationUnits().put(cu, info);
}
// This is an internal delete call.
protected void primDelete(ICompilationUnit cu) {
try {
if (cu.exists())
cu.delete(true, new org.eclipse.core.runtime.NullProgressMonitor());
} catch (JavaModelException e) {
org.eclipse.jem.util.logger.proxy.Logger.getLogger().logError(e);
//What to do here?
}
}
protected void primDispose() {
discardOriginalNewCompilationUnits();
reviveDeletedCompilationUnits();
newCompilationUnits = null;
needsSavingCompilationUnits = null;
originalNewCompilationUnits = null;
deletedCompilationUnits = null;
}
protected void primRevert() {
discardOriginalNewCompilationUnits();
reviveDeletedCompilationUnits();
newCompilationUnits = null;
needsSavingCompilationUnits = null;
originalNewCompilationUnits = null;
deletedCompilationUnits = null;
}
/**
* Returns the working copy remembered for the compilation unit encoded in the given editor
* input.
*
* @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
*/
protected ICompilationUnit primGetWorkingCopy(ICompilationUnit cu) throws CoreException {
return null;
}
/**
* This will save all of the referenced CompilationUnits to be saved.
*/
protected void primSaveCompilationUnits(org.eclipse.core.runtime.IProgressMonitor monitor) {
saveNewCompilationUnits(monitor);
getDeletedCompilationUnits().clear();
}
/**
* This will save all of the new CompilationUnits to be saved.
*/
protected void primSaveOnlyNewCompilationUnits(org.eclipse.core.runtime.IProgressMonitor monitor) {
List cus = getNeedsSavingCompilationUnits();
ICompilationUnit wc;
for (int i = 0; i < cus.size(); i++) {
wc = (ICompilationUnit) cus.get(i);
commitWorkingCopy(wc, monitor);
}
cus.clear();
}
protected void removeDeletedCompilationUnit(ICompilationUnit cu) {
if (getDeletedCompilationUnits().remove(cu) != null) {
if (cu.isWorkingCopy()) {
ICompilationUnit original, nextCU, testCU;
original = cu.getPrimary();
Set cus = getDeletedCompilationUnits().keySet();
Iterator it = cus.iterator();
while (it.hasNext()) {
nextCU = (ICompilationUnit) it.next();
testCU = nextCU.isWorkingCopy() ? (ICompilationUnit) nextCU.getPrimary() : nextCU;
if (testCU.equals(original)) {
cus.remove(nextCU);
return;
}
}
}
}
}
protected void reviveDeletedCompilationUnit(ICompilationUnit cu, Object[] info, IProgressMonitor pm) {
if(cu.getJavaProject().isOpen()) {
if (info[0] != null && info[1] != null) {
String typeName = cu.getElementName();
IPackageFragment pack = (IPackageFragment) info[0];
String source = (String) info[1];
try {
ICompilationUnit existingCU = pack.getCompilationUnit(typeName);
if (existingCU.exists() && getNewCompilationUnits().contains(existingCU))
existingCU.delete(false, pm);
pack.createCompilationUnit(typeName, source, false, pm);
} catch (JavaModelException e) {
org.eclipse.jem.util.logger.proxy.Logger.getLogger().logError(e);
}
}
}
}
protected void reviveDeletedCompilationUnits() {
if (getDeletedCompilationUnits().isEmpty())
return;
IProgressMonitor pm = new org.eclipse.core.runtime.NullProgressMonitor();
Iterator it = getDeletedCompilationUnits().entrySet().iterator();
Map.Entry entry;
ICompilationUnit cu;
Object[] info;
while (it.hasNext()) {
entry = (Map.Entry) it.next();
cu = (ICompilationUnit) entry.getKey();
info = (Object[]) entry.getValue();
reviveDeletedCompilationUnit(cu, info, pm);
}
}
protected void runOperation(IWorkspaceRunnable aRunnable, IProgressMonitor monitor, boolean validate) {
primRunOperation(aRunnable, monitor);
// TODO Break the validator depedency
// if (validate)
// primRunOperation(aRunnable, monitor);
// else {
// IProject proj = getValidationProject();
//
// ValidatorManager mgr = ValidatorManager.getManager();
// boolean disableValidators = proj != null;
// boolean wasSuspended = false;
// if (disableValidators) {
// wasSuspended = mgr.isSuspended(proj);
// if (!wasSuspended)
// mgr.suspendValidation(proj, true);
// }
// try {
// primRunOperation(aRunnable, monitor);
// } finally {
// if (disableValidators && !wasSuspended)
// mgr.suspendValidation(proj, false);
// }
// }
}
protected void primRunOperation(IWorkspaceRunnable aRunnable, IProgressMonitor monitor) {
if (aRunnable != null) {
//if (workspace.isTreeLocked())
//Logger.getLogger().logTrace(ResourceHandler.getString("Cannot_run_J2EEUIWorkingCo_ERROR_"));
// //$NON-NLS-1$ = "Cannot run J2EEUIWorkingCopyManager operation because the Workspace
// tree is locked."
//else {
if (!WTPCommonPlugin.getWorkspace().isTreeLocked()) {
try {
WTPCommonPlugin.getWorkspace().run(aRunnable, monitor);
} catch (CoreException e) {
throw new SaveFailedException(e);
}
}
}
}
/**
* This will save all of the referenced CompilationUnits to be saved.
*/
public void saveCompilationUnits(org.eclipse.core.runtime.IProgressMonitor monitor) {
getSaveHandler().access();
try {
IWorkspaceRunnable runnable = new IWorkspaceRunnable() {
public void run(IProgressMonitor aMonitor) {
primSaveCompilationUnits(aMonitor);
}
};
runOperation(runnable, monitor, true);
} catch (SaveFailedException ex) {
getSaveHandler().handleSaveFailed(ex, monitor);
} finally {
getSaveHandler().release();
}
}
/**
* This will save all of the referenced CompilationUnits to be saved.
*/
protected void saveNewCompilationUnits(IProgressMonitor monitor) {
primSaveOnlyNewCompilationUnits(monitor);
getOriginalNewCompilationUnits().clear();
getNewCompilationUnits().clear();
}
/**
* This will save all of the new CompilationUnits to be saved.
*/
public void saveOnlyNewCompilationUnits(org.eclipse.core.runtime.IProgressMonitor monitor) {
getSaveHandler().access();
try {
IWorkspaceRunnable runnable = new IWorkspaceRunnable() {
public void run(IProgressMonitor aMonitor) {
primSaveOnlyNewCompilationUnits(aMonitor);
}
};
runOperation(runnable, monitor, false);
} catch (SaveFailedException ex) {
getSaveHandler().handleSaveFailed(ex, monitor);
} finally {
getSaveHandler().release();
}
}
protected boolean shouldSaveReadOnly(ICompilationUnit wc) {
IResource resource = null;
resource = (IResource) wc.getPrimary().getAdapter(IRESOURCE_CLASS);
if (resource == null || resource.getType() != IResource.FILE || !resource.getResourceAttributes().isReadOnly())
return false;
return getSaveHandler().shouldContinueAndMakeFileEditable((IFile) resource);
}
/**
* @see com.ibm.etools.j2ee.workbench.IJ2EEWorkingCopyManager#hasWorkingCopies()
*/
public boolean hasWorkingCopies() {
return (deletedCompilationUnits != null && !deletedCompilationUnits.isEmpty()) || (needsSavingCompilationUnits != null && !needsSavingCompilationUnits.isEmpty()) || (newCompilationUnits != null && !newCompilationUnits.isEmpty());
}
}