plugins/org.eclipse.wst.common.frameworks/src/org/eclipse/wst/common/frameworks/internal/OperationManager.java - webtools-common/webtools.common - Git at Google

 /***************************************************************************************************
  * Copyright (c) 2003, 2005 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.wst.common.frameworks.internal;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 import java.util.Stack;
 import java.util.Vector;

 import org.eclipse.core.commands.ExecutionException;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.core.runtime.jobs.ISchedulingRule;
 import org.eclipse.wst.common.environment.IEnvironment;
 import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelOperation;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
 import org.eclipse.wst.common.frameworks.internal.datamodel.IWorkspaceRunnableWithStatus;
 import org.eclipse.wst.common.frameworks.internal.operations.ComposedExtendedOperationHolder;
 import org.eclipse.wst.common.frameworks.internal.operations.OperationStatus;

 public class OperationManager {
 	private IDataModel dataModel;
 	private DataModelManager dataModelManager;
 	private TableEntry rootOperation;
 	private HashMap operationTable;
 	private Stack runStopList;
 	private IProgressMonitor monitor;
 	private IAdaptable adaptable;
 	private OperationStatus status;
 	private OperationListener preExecuteListener;
 	private OperationListener postExecuteListener;
 	private OperationListener undoExecuteListener;
   private IEnvironment       environment;

 	public OperationManager(DataModelManager aDataModelManager, IDataModelOperation aRootOperation, IEnvironment aEnvironment) {
 		if (aRootOperation == null)
 			aRootOperation = new NullOperation();

 		TableEntry entry = new TableEntry(aRootOperation);

 		dataModelManager = aDataModelManager;
 		dataModel = dataModelManager.getDataModel();
 		rootOperation = entry;
 		operationTable = new HashMap();
 		runStopList = new Stack();
 		operationTable.put(aRootOperation.getID(), entry);
     environment = aEnvironment;
  		addExtendedOperations(aRootOperation);

 		OperationListener defaultListener = new OperationListener() {
 			public boolean notify(IDataModelOperation operation) {
 				return true;
 			}
 		};

 		preExecuteListener = defaultListener;
 		postExecuteListener = defaultListener;
 		undoExecuteListener = defaultListener;
 	}

 	public void setProgressMonitor(IProgressMonitor monitor) {
 		this.monitor = monitor;
 	}

 	public void setAdaptable(IAdaptable adaptable) {
 		this.adaptable = adaptable;
 	}

 	public void addExtendedPreOperation(String operationId, IDataModelOperation insertOperation) {
 		TableEntry entry = (TableEntry) operationTable.get(operationId);

 		if (entry != null) {
 			TableEntry newEntry = new TableEntry(insertOperation);

 			entry.preOperations.add(newEntry);
 			operationTable.put(insertOperation.getID(), newEntry);
 		}
 	}

 	public void addExtendedPostOperation(String operationId, IDataModelOperation insertOperation) {
 		TableEntry entry = (TableEntry) operationTable.get(operationId);

 		if (entry != null) {
 			TableEntry newEntry = new TableEntry(insertOperation);

 			entry.postOperations.add(newEntry);
 			operationTable.put(insertOperation.getID(), newEntry);
 		}
 	}

 	public void setPreExecuteListener(OperationListener listener) {
 		if (listener != null)
 			preExecuteListener = listener;
 	}

 	public void setPostExecuteListener(OperationListener listener) {
 		if (listener != null)
 			postExecuteListener = listener;
 	}

 	public void setUndoExecuteListener(OperationListener listener) {
 		if (listener != null)
 			undoExecuteListener = listener;
 	}

 	public IStatus runOperations() {
 		boolean continueRun = true;
 		RunListEntry runEntry = startNewRun();

 		status = null;

 		// All operations have already been run so just return OK.
 		if (runEntry.stackEntries.empty())
 			return Status.OK_STATUS;

 		while (continueRun) {
 			continueRun = runOperationsUntilStopped(runEntry) && !runEntry.stackEntries.empty();
 		}

 		if (status != null && status.getSeverity() == IStatus.ERROR) {
 			undoLastRun();
 		}
 		return status;
 	}

 	public void undoLastRun() {
 		if (!runStopList.empty()) {
 			RunListEntry runListEntry = (RunListEntry) runStopList.pop();

 			for (int index = runListEntry.executedOperations.size() - 1; index >= 0; index--) {
 				IDataModelOperation operation = (IDataModelOperation) runListEntry.executedOperations.elementAt(index);
 				Set dataModelIDs = operation.getDataModelIDs();

 				if( dataModelIDs != null && dataModelIDs.size() > 0 )
         {
           Iterator ids = dataModelIDs.iterator();

           while( ids.hasNext() )
           {
             String dataModelID = (String)ids.next();
 					  dataModelManager.removeNestedDataModel(dataModelID);
           }
         }

 				try {
 					undoExecuteListener.notify(operation);
 				} catch (Throwable exc) {
 					// TODO report undo notify exception.
 				}

 				if (operation.canUndo()) {
 					try {
 						runOperation(operation, true);
 					} catch (Throwable exc) {
 						// TODO report an undo exception here.
 					}
 				}
 			}
 		}
 	}

 	private RunListEntry startNewRun() {
 		RunListEntry newEntry = null;

 		if (runStopList.empty()) {
 			newEntry = new RunListEntry(rootOperation);
 		} else {
 			RunListEntry topRunList = (RunListEntry) runStopList.peek();
 			newEntry = new RunListEntry(topRunList);
 		}

 		runStopList.push(newEntry);

 		return newEntry;
 	}

 	private boolean runOperationsUntilStopped(RunListEntry runListEntry) {
 		StackEntry stackEntry = (StackEntry) runListEntry.stackEntries.peek();
 		boolean continueRun = true;

 		// Run extended pre operations.
 		for (int index = stackEntry.preOperationIndex + 1; continueRun && index < stackEntry.tableEntry.preOperations.size(); index++) {
 			TableEntry tableEntry = (TableEntry) stackEntry.tableEntry.preOperations.elementAt(index);

 			runListEntry.stackEntries.push(new StackEntry(tableEntry));
 			stackEntry.preOperationIndex = index;
 			continueRun = runOperationsUntilStopped(runListEntry);
 		}

     if( continueRun && stackEntry.preOpChildIndex == -1 ) stackEntry.addPreOpChildren();

     // Run child pre operations.
     for (int index = stackEntry.preOpChildIndex + 1; continueRun && index < stackEntry.preOpChildren.size(); index++) {
       TableEntry tableEntry = (TableEntry) stackEntry.preOpChildren.elementAt(index);

       runListEntry.stackEntries.push(new StackEntry(tableEntry));
       stackEntry.preOpChildIndex = index;
       continueRun = runOperationsUntilStopped(runListEntry);
     }

 		if (continueRun && !stackEntry.operationExecuted) {
 			IDataModelOperation operation = stackEntry.tableEntry.operation;

 			try {
 				continueRun = preExecuteListener.notify(operation);

 				if (continueRun) {
 					Set dataModelIDs = operation.getDataModelIDs();

 					if (dataModelIDs != null && dataModelIDs.size() > 0 )
           {
             Iterator ids = dataModelIDs.iterator();

             while( ids.hasNext() )
             {
               String dataModelID = (String)ids.next();
 						  dataModelManager.addNestedDataModel(dataModelID);
             }
           }

 					operation.setDataModel(dataModel);
           operation.setEnvironment( environment );
 					setStatus(runOperation(operation, false));
 					runListEntry.executedOperations.add(operation);
 					stackEntry.operationExecuted = true;
 					continueRun = postExecuteListener.notify(operation);
 				}
 			} catch (Throwable exc) {
 				setStatus(new Status(IStatus.ERROR, "id", 0, exc.getMessage() == null ? exc.toString() : exc.getMessage(), exc));
 			}

 			if (status != null && status.getSeverity() == IStatus.ERROR) {
 				// This isn't really true, but it will cause the run operations to stop.
 				continueRun = false;
 			}
 		}

     if( continueRun && stackEntry.postOpChildIndex == -1 ) stackEntry.addPostOpChildren();

     // Run child post operations.
     for (int index = stackEntry.postOpChildIndex + 1; continueRun && index < stackEntry.postOpChildren.size(); index++) {
       TableEntry tableEntry = (TableEntry) stackEntry.postOpChildren.elementAt(index);

       stackEntry.postOpChildIndex = index;
       runListEntry.stackEntries.push(new StackEntry(tableEntry));
       continueRun = runOperationsUntilStopped(runListEntry);
     }

 		// Run extended post operations.
 		for (int index = stackEntry.postOperationIndex + 1; continueRun && index < stackEntry.tableEntry.postOperations.size(); index++) {
 			TableEntry tableEntry = (TableEntry) stackEntry.tableEntry.postOperations.elementAt(index);

 			stackEntry.postOperationIndex = index;
 			runListEntry.stackEntries.push(new StackEntry(tableEntry));
 			continueRun = runOperationsUntilStopped(runListEntry);
 		}

 		// If we are have run the pre ops, this operation, and
 		// the post ops, we should pop this entry off the stack.
 		// Also, if continueRun is false we don't want to pop the stack since we will want to come
 		// back to this entry later.
 		if (continueRun) {
 			runListEntry.stackEntries.pop();
 		}

 		return continueRun;
 	}

 	private IStatus runOperation(final IDataModelOperation operation, final boolean isUndo) {
 		IWorkspaceRunnableWithStatus workspaceRunnable = new IWorkspaceRunnableWithStatus(adaptable) {
 			public void run(IProgressMonitor pm) throws CoreException {
 				try {
 					if (isUndo) {
 						this.setStatus(operation.undo(monitor, getInfo()));
 					} else {
 						this.setStatus(operation.execute(monitor, getInfo()));
 					}
 				} catch (Throwable exc) {
 					exc.printStackTrace();
 				}
 			}
 		};

 		ISchedulingRule rule = operation.getSchedulingRule();

 		try {
 			if (rule == null) {
 				ResourcesPlugin.getWorkspace().run(workspaceRunnable, monitor);
 			} else {
 				ResourcesPlugin.getWorkspace().run(workspaceRunnable, rule, operation.getOperationExecutionFlags(), monitor);
 			}
 		} catch (CoreException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 		return workspaceRunnable.getStatus();
 	}

 	private void setStatus(IStatus newStatus) {
 		if (status == null) {
 			status = new OperationStatus(newStatus.getMessage(), newStatus.getException());
 			status.setSeverity(newStatus.getSeverity());
 			status.add(newStatus);
 		} else {
 			status.add(newStatus);
 		}
 	}

 	private void addExtendedOperations(IDataModelOperation operation) {
 		ComposedExtendedOperationHolder extendedOps = ComposedExtendedOperationHolder.createExtendedOperationHolder(operation.getID());

 		ArrayList preOps = null;
 		ArrayList postOps = null;

 		if (extendedOps != null) {
 			preOps = extendedOps.getPreOps();
 			postOps = extendedOps.getPostOps();
 		}

 		if (preOps == null)
 			preOps = new ArrayList();
 		if (postOps == null)
 			postOps = new ArrayList();

 		for (int index = 0; index < preOps.size(); index++) {
 			IDataModelOperation newOperation = (IDataModelOperation) preOps.get(index);

 			addExtendedPreOperation(operation.getID(), newOperation);
 			addExtendedOperations(newOperation);
 		}

 		for (int index = 0; index < postOps.size(); index++) {
 			IDataModelOperation newOperation = (IDataModelOperation) postOps.get(index);

 			addExtendedPostOperation(operation.getID(), newOperation);
 			addExtendedOperations(newOperation);
 		}
 	}

 	private class RunListEntry {
 		public Stack stackEntries;
 		public Vector executedOperations;

 		public RunListEntry(TableEntry newEntry) {
 			stackEntries = new Stack();
 			executedOperations = new Vector();
 			stackEntries.push(new StackEntry(newEntry));
 		}

 		public RunListEntry(RunListEntry oldList) {
 			stackEntries = new Stack();
 			executedOperations = new Vector();

 			for (int index = 0; index < oldList.stackEntries.size(); index++) {
 				StackEntry oldEntry = (StackEntry) oldList.stackEntries.elementAt(index);
 				stackEntries.add(new StackEntry(oldEntry));
 			}
 		}
 	}

 	private class StackEntry {
 		public int preOperationIndex;
 		public int postOperationIndex;
     public int preOpChildIndex;
     public int postOpChildIndex;
 		public boolean operationExecuted;
     public Vector preOpChildren;
     public Vector postOpChildren;
 		public TableEntry tableEntry;

 		public StackEntry(TableEntry newTableEntry) {
 			preOperationIndex = -1;
 			postOperationIndex = -1;
 			operationExecuted = false;
       preOpChildIndex = -1;
       postOpChildIndex = -1;
 			tableEntry = newTableEntry;
 		}

 		public StackEntry(StackEntry newStackEntry) {
 			preOperationIndex = newStackEntry.preOperationIndex;
 			postOperationIndex = newStackEntry.postOperationIndex;
 			operationExecuted = newStackEntry.operationExecuted;
 			tableEntry = newStackEntry.tableEntry;
       preOpChildIndex = newStackEntry.preOpChildIndex;
       postOpChildIndex = newStackEntry.postOpChildIndex;
       preOpChildren     = newStackEntry.preOpChildren == null ? null :new Vector( newStackEntry.preOpChildren );
       postOpChildren    = newStackEntry.postOpChildren == null ? null : new Vector( newStackEntry.postOpChildren );
 		}

     public void addPreOpChildren()
     {
       List preOps = tableEntry.operation.getPreOperations();

       preOpChildren = new Vector();

       if( preOps != null )
       {
         for( int index = 0; index < preOps.size(); index++ )
         {
           IDataModelOperation op       = (IDataModelOperation)preOps.get( index );
           TableEntry          newEntry = new TableEntry(op);

           preOpChildren.add( newEntry );
           operationTable.put( op.getID(), newEntry );
           addExtendedOperations( op );
         }
       }
     }

     public void addPostOpChildren()
     {
       List postOps = tableEntry.operation.getPostOperations();

       postOpChildren = new Vector();

       if( postOps != null )
       {
         for( int index = 0; index < postOps.size(); index++ )
         {
           IDataModelOperation op       = (IDataModelOperation)postOps.get( index );
           TableEntry          newEntry = new TableEntry(op);

           postOpChildren.add( newEntry );
           operationTable.put( op.getID(), newEntry );
           addExtendedOperations( op );
         }
       }
     }
 	}

 	private class TableEntry {
 		public IDataModelOperation operation;
 		public Vector preOperations;
 		public Vector postOperations;

 		public TableEntry(IDataModelOperation newOperation) {
 			operation = newOperation;
 			preOperations = new Vector(3);
 			postOperations = new Vector(3);
 		}
 	}

 	private class NullOperation extends AbstractDataModelOperation {
 		public IStatus execute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
 			return Status.OK_STATUS;
 		}

 		public IStatus redo(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
 			return Status.OK_STATUS;
 		}

 		public IStatus undo(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
 			return Status.OK_STATUS;
 		}

 	}
 }
	/***************************************************************************************************
	* Copyright (c) 2003, 2005 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.wst.common.frameworks.internal;

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Set;
	import java.util.Stack;
	import java.util.Vector;

	import org.eclipse.core.commands.ExecutionException;
	import org.eclipse.core.resources.ResourcesPlugin;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IAdaptable;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.core.runtime.jobs.ISchedulingRule;
	import org.eclipse.wst.common.environment.IEnvironment;
	import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelOperation;
	import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
	import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
	import org.eclipse.wst.common.frameworks.internal.datamodel.IWorkspaceRunnableWithStatus;
	import org.eclipse.wst.common.frameworks.internal.operations.ComposedExtendedOperationHolder;
	import org.eclipse.wst.common.frameworks.internal.operations.OperationStatus;

	public class OperationManager {
	private IDataModel dataModel;
	private DataModelManager dataModelManager;
	private TableEntry rootOperation;
	private HashMap operationTable;
	private Stack runStopList;
	private IProgressMonitor monitor;
	private IAdaptable adaptable;
	private OperationStatus status;
	private OperationListener preExecuteListener;
	private OperationListener postExecuteListener;
	private OperationListener undoExecuteListener;
	private IEnvironment environment;

	public OperationManager(DataModelManager aDataModelManager, IDataModelOperation aRootOperation, IEnvironment aEnvironment) {
	if (aRootOperation == null)
	aRootOperation = new NullOperation();

	TableEntry entry = new TableEntry(aRootOperation);

	dataModelManager = aDataModelManager;
	dataModel = dataModelManager.getDataModel();
	rootOperation = entry;
	operationTable = new HashMap();
	runStopList = new Stack();
	operationTable.put(aRootOperation.getID(), entry);
	environment = aEnvironment;
	addExtendedOperations(aRootOperation);

	OperationListener defaultListener = new OperationListener() {
	public boolean notify(IDataModelOperation operation) {
	return true;
	}
	};

	preExecuteListener = defaultListener;
	postExecuteListener = defaultListener;
	undoExecuteListener = defaultListener;
	}

	public void setProgressMonitor(IProgressMonitor monitor) {
	this.monitor = monitor;
	}

	public void setAdaptable(IAdaptable adaptable) {
	this.adaptable = adaptable;
	}

	public void addExtendedPreOperation(String operationId, IDataModelOperation insertOperation) {
	TableEntry entry = (TableEntry) operationTable.get(operationId);

	if (entry != null) {
	TableEntry newEntry = new TableEntry(insertOperation);

	entry.preOperations.add(newEntry);
	operationTable.put(insertOperation.getID(), newEntry);
	}
	}

	public void addExtendedPostOperation(String operationId, IDataModelOperation insertOperation) {
	TableEntry entry = (TableEntry) operationTable.get(operationId);

	if (entry != null) {
	TableEntry newEntry = new TableEntry(insertOperation);

	entry.postOperations.add(newEntry);
	operationTable.put(insertOperation.getID(), newEntry);
	}
	}

	public void setPreExecuteListener(OperationListener listener) {
	if (listener != null)
	preExecuteListener = listener;
	}

	public void setPostExecuteListener(OperationListener listener) {
	if (listener != null)
	postExecuteListener = listener;
	}

	public void setUndoExecuteListener(OperationListener listener) {
	if (listener != null)
	undoExecuteListener = listener;
	}

	public IStatus runOperations() {
	boolean continueRun = true;
	RunListEntry runEntry = startNewRun();

	status = null;

	// All operations have already been run so just return OK.
	if (runEntry.stackEntries.empty())
	return Status.OK_STATUS;

	while (continueRun) {
	continueRun = runOperationsUntilStopped(runEntry) && !runEntry.stackEntries.empty();
	}

	if (status != null && status.getSeverity() == IStatus.ERROR) {
	undoLastRun();
	}
	return status;
	}

	public void undoLastRun() {
	if (!runStopList.empty()) {
	RunListEntry runListEntry = (RunListEntry) runStopList.pop();

	for (int index = runListEntry.executedOperations.size() - 1; index >= 0; index--) {
	IDataModelOperation operation = (IDataModelOperation) runListEntry.executedOperations.elementAt(index);
	Set dataModelIDs = operation.getDataModelIDs();

	if( dataModelIDs != null && dataModelIDs.size() > 0 )
	{
	Iterator ids = dataModelIDs.iterator();

	while( ids.hasNext() )
	{
	String dataModelID = (String)ids.next();
	dataModelManager.removeNestedDataModel(dataModelID);
	}
	}

	try {
	undoExecuteListener.notify(operation);
	} catch (Throwable exc) {
	// TODO report undo notify exception.
	}

	if (operation.canUndo()) {
	try {
	runOperation(operation, true);
	} catch (Throwable exc) {
	// TODO report an undo exception here.
	}
	}
	}
	}
	}

	private RunListEntry startNewRun() {
	RunListEntry newEntry = null;

	if (runStopList.empty()) {
	newEntry = new RunListEntry(rootOperation);
	} else {
	RunListEntry topRunList = (RunListEntry) runStopList.peek();
	newEntry = new RunListEntry(topRunList);
	}

	runStopList.push(newEntry);

	return newEntry;
	}

	private boolean runOperationsUntilStopped(RunListEntry runListEntry) {
	StackEntry stackEntry = (StackEntry) runListEntry.stackEntries.peek();
	boolean continueRun = true;

	// Run extended pre operations.
	for (int index = stackEntry.preOperationIndex + 1; continueRun && index < stackEntry.tableEntry.preOperations.size(); index++) {
	TableEntry tableEntry = (TableEntry) stackEntry.tableEntry.preOperations.elementAt(index);

	runListEntry.stackEntries.push(new StackEntry(tableEntry));
	stackEntry.preOperationIndex = index;
	continueRun = runOperationsUntilStopped(runListEntry);
	}

	if( continueRun && stackEntry.preOpChildIndex == -1 ) stackEntry.addPreOpChildren();

	// Run child pre operations.
	for (int index = stackEntry.preOpChildIndex + 1; continueRun && index < stackEntry.preOpChildren.size(); index++) {
	TableEntry tableEntry = (TableEntry) stackEntry.preOpChildren.elementAt(index);

	runListEntry.stackEntries.push(new StackEntry(tableEntry));
	stackEntry.preOpChildIndex = index;
	continueRun = runOperationsUntilStopped(runListEntry);
	}

	if (continueRun && !stackEntry.operationExecuted) {
	IDataModelOperation operation = stackEntry.tableEntry.operation;

	try {
	continueRun = preExecuteListener.notify(operation);

	if (continueRun) {
	Set dataModelIDs = operation.getDataModelIDs();

	if (dataModelIDs != null && dataModelIDs.size() > 0 )
	{
	Iterator ids = dataModelIDs.iterator();

	while( ids.hasNext() )
	{
	String dataModelID = (String)ids.next();
	dataModelManager.addNestedDataModel(dataModelID);
	}
	}

	operation.setDataModel(dataModel);
	operation.setEnvironment( environment );
	setStatus(runOperation(operation, false));
	runListEntry.executedOperations.add(operation);
	stackEntry.operationExecuted = true;
	continueRun = postExecuteListener.notify(operation);
	}
	} catch (Throwable exc) {
	setStatus(new Status(IStatus.ERROR, "id", 0, exc.getMessage() == null ? exc.toString() : exc.getMessage(), exc));
	}

	if (status != null && status.getSeverity() == IStatus.ERROR) {
	// This isn't really true, but it will cause the run operations to stop.
	continueRun = false;
	}
	}

	if( continueRun && stackEntry.postOpChildIndex == -1 ) stackEntry.addPostOpChildren();

	// Run child post operations.
	for (int index = stackEntry.postOpChildIndex + 1; continueRun && index < stackEntry.postOpChildren.size(); index++) {
	TableEntry tableEntry = (TableEntry) stackEntry.postOpChildren.elementAt(index);

	stackEntry.postOpChildIndex = index;
	runListEntry.stackEntries.push(new StackEntry(tableEntry));
	continueRun = runOperationsUntilStopped(runListEntry);
	}

	// Run extended post operations.
	for (int index = stackEntry.postOperationIndex + 1; continueRun && index < stackEntry.tableEntry.postOperations.size(); index++) {
	TableEntry tableEntry = (TableEntry) stackEntry.tableEntry.postOperations.elementAt(index);

	stackEntry.postOperationIndex = index;
	runListEntry.stackEntries.push(new StackEntry(tableEntry));
	continueRun = runOperationsUntilStopped(runListEntry);
	}

	// If we are have run the pre ops, this operation, and
	// the post ops, we should pop this entry off the stack.
	// Also, if continueRun is false we don't want to pop the stack since we will want to come
	// back to this entry later.
	if (continueRun) {
	runListEntry.stackEntries.pop();
	}

	return continueRun;
	}

	private IStatus runOperation(final IDataModelOperation operation, final boolean isUndo) {
	IWorkspaceRunnableWithStatus workspaceRunnable = new IWorkspaceRunnableWithStatus(adaptable) {
	public void run(IProgressMonitor pm) throws CoreException {
	try {
	if (isUndo) {
	this.setStatus(operation.undo(monitor, getInfo()));
	} else {
	this.setStatus(operation.execute(monitor, getInfo()));
	}
	} catch (Throwable exc) {
	exc.printStackTrace();
	}
	}
	};

	ISchedulingRule rule = operation.getSchedulingRule();

	try {
	if (rule == null) {
	ResourcesPlugin.getWorkspace().run(workspaceRunnable, monitor);
	} else {
	ResourcesPlugin.getWorkspace().run(workspaceRunnable, rule, operation.getOperationExecutionFlags(), monitor);
	}
	} catch (CoreException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
	}
	return workspaceRunnable.getStatus();
	}

	private void setStatus(IStatus newStatus) {
	if (status == null) {
	status = new OperationStatus(newStatus.getMessage(), newStatus.getException());
	status.setSeverity(newStatus.getSeverity());
	status.add(newStatus);
	} else {
	status.add(newStatus);
	}
	}

	private void addExtendedOperations(IDataModelOperation operation) {
	ComposedExtendedOperationHolder extendedOps = ComposedExtendedOperationHolder.createExtendedOperationHolder(operation.getID());

	ArrayList preOps = null;
	ArrayList postOps = null;

	if (extendedOps != null) {
	preOps = extendedOps.getPreOps();
	postOps = extendedOps.getPostOps();
	}

	if (preOps == null)
	preOps = new ArrayList();
	if (postOps == null)
	postOps = new ArrayList();

	for (int index = 0; index < preOps.size(); index++) {
	IDataModelOperation newOperation = (IDataModelOperation) preOps.get(index);

	addExtendedPreOperation(operation.getID(), newOperation);
	addExtendedOperations(newOperation);
	}

	for (int index = 0; index < postOps.size(); index++) {
	IDataModelOperation newOperation = (IDataModelOperation) postOps.get(index);

	addExtendedPostOperation(operation.getID(), newOperation);
	addExtendedOperations(newOperation);
	}
	}

	private class RunListEntry {
	public Stack stackEntries;
	public Vector executedOperations;

	public RunListEntry(TableEntry newEntry) {
	stackEntries = new Stack();
	executedOperations = new Vector();
	stackEntries.push(new StackEntry(newEntry));
	}

	public RunListEntry(RunListEntry oldList) {
	stackEntries = new Stack();
	executedOperations = new Vector();

	for (int index = 0; index < oldList.stackEntries.size(); index++) {
	StackEntry oldEntry = (StackEntry) oldList.stackEntries.elementAt(index);
	stackEntries.add(new StackEntry(oldEntry));
	}
	}
	}

	private class StackEntry {
	public int preOperationIndex;
	public int postOperationIndex;
	public int preOpChildIndex;
	public int postOpChildIndex;
	public boolean operationExecuted;
	public Vector preOpChildren;
	public Vector postOpChildren;
	public TableEntry tableEntry;

	public StackEntry(TableEntry newTableEntry) {
	preOperationIndex = -1;
	postOperationIndex = -1;
	operationExecuted = false;
	preOpChildIndex = -1;
	postOpChildIndex = -1;
	tableEntry = newTableEntry;
	}

	public StackEntry(StackEntry newStackEntry) {
	preOperationIndex = newStackEntry.preOperationIndex;
	postOperationIndex = newStackEntry.postOperationIndex;
	operationExecuted = newStackEntry.operationExecuted;
	tableEntry = newStackEntry.tableEntry;
	preOpChildIndex = newStackEntry.preOpChildIndex;
	postOpChildIndex = newStackEntry.postOpChildIndex;
	preOpChildren = newStackEntry.preOpChildren == null ? null :new Vector( newStackEntry.preOpChildren );
	postOpChildren = newStackEntry.postOpChildren == null ? null : new Vector( newStackEntry.postOpChildren );
	}

	public void addPreOpChildren()
	{
	List preOps = tableEntry.operation.getPreOperations();

	preOpChildren = new Vector();

	if( preOps != null )
	{
	for( int index = 0; index < preOps.size(); index++ )
	{
	IDataModelOperation op = (IDataModelOperation)preOps.get( index );
	TableEntry newEntry = new TableEntry(op);

	preOpChildren.add( newEntry );
	operationTable.put( op.getID(), newEntry );
	addExtendedOperations( op );
	}
	}
	}

	public void addPostOpChildren()
	{
	List postOps = tableEntry.operation.getPostOperations();

	postOpChildren = new Vector();

	if( postOps != null )
	{
	for( int index = 0; index < postOps.size(); index++ )
	{
	IDataModelOperation op = (IDataModelOperation)postOps.get( index );
	TableEntry newEntry = new TableEntry(op);

	postOpChildren.add( newEntry );
	operationTable.put( op.getID(), newEntry );
	addExtendedOperations( op );
	}
	}
	}
	}

	private class TableEntry {
	public IDataModelOperation operation;
	public Vector preOperations;
	public Vector postOperations;

	public TableEntry(IDataModelOperation newOperation) {
	operation = newOperation;
	preOperations = new Vector(3);
	postOperations = new Vector(3);
	}
	}

	private class NullOperation extends AbstractDataModelOperation {
	public IStatus execute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
	return Status.OK_STATUS;
	}

	public IStatus redo(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
	return Status.OK_STATUS;
	}

	public IStatus undo(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
	return Status.OK_STATUS;
	}

	}
	}