| /****************************************************************************** |
| * Copyright (c) 2006, 2009 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.gmf.runtime.common.core.command; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.ListIterator; |
| |
| import org.eclipse.core.commands.ExecutionException; |
| import org.eclipse.core.commands.operations.ICompositeOperation; |
| import org.eclipse.core.commands.operations.IUndoContext; |
| import org.eclipse.core.commands.operations.IUndoableOperation; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.MultiStatus; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.SubProgressMonitor; |
| import org.eclipse.gmf.runtime.common.core.internal.CommonCoreDebugOptions; |
| import org.eclipse.gmf.runtime.common.core.internal.CommonCorePlugin; |
| import org.eclipse.gmf.runtime.common.core.internal.CommonCoreStatusCodes; |
| import org.eclipse.gmf.runtime.common.core.internal.l10n.CommonCoreMessages; |
| import org.eclipse.gmf.runtime.common.core.util.Log; |
| import org.eclipse.gmf.runtime.common.core.util.Trace; |
| |
| /** |
| * An undoable command that is composed of child {@link IUndoableOperation}s |
| * that are not known to modify EMF model resources, but can contain |
| * model-affecting children. Execute, undo, redo and dispose result in execute, |
| * undo, redo and dispose on each child operation. The operation provides a list |
| * of {@link IFile}s that may be modified when the operation is executed, |
| * undone or redone. |
| * <P> |
| * The children are explicitly composed by a client before the composite is |
| * executed. Children cannot be added or removed after the composite has been |
| * executed. |
| * <P> |
| * The undo contexts of the composite are a union of the undo contexts of its |
| * children. |
| * <P> |
| * If a child command returns a cancel or an error status during execution, undo |
| * or redo, the remaining child commands are not processed and those that have |
| * already been executed are rolled back. |
| * |
| * @author ldamus |
| */ |
| public class CompositeCommand |
| extends AbstractCommand |
| implements ICompositeCommand { |
| |
| private final List children; |
| |
| private boolean executed; |
| |
| /** |
| * Initializes me with a label. |
| * |
| * @param label |
| * a user-readable label |
| */ |
| public CompositeCommand(String label) { |
| this(label, null); |
| } |
| |
| /** |
| * Initializes me with a label and a list of child operations. |
| * |
| * @param label |
| * a user-readable label |
| * @param children |
| * a list of child {@link IUndoableOperation}s |
| */ |
| public CompositeCommand(String label, List children) { |
| super(label, null); |
| |
| if (children != null) { |
| this.children = new ArrayList(children); |
| } else { |
| this.children = new ArrayList(4); |
| } |
| } |
| |
| /** |
| * Answers whether or not this composite operation has children. |
| * |
| * @return <code>true</code> if the operation does not have children, |
| * <code>false</code> otherwise. |
| */ |
| public final boolean isEmpty() { |
| return size() < 1; |
| } |
| |
| /** |
| * Obtains my nested operations. Note that the return result is mutable and |
| * is identical to my child-operation storage, so subclasses should be |
| * careful of adding or removing contents. This should ordinarily be done |
| * only via the {@link #add(IUndoableOperation)} and |
| * {@link #remove(IUndoableOperation)} methods because these maintain the |
| * undo contexts (or, equivalently, using the iterators). |
| * |
| * @return my list of children |
| * |
| * @see #add(IUndoableOperation) |
| * @see #remove(IUndoableOperation) |
| * @see #iterator() |
| * @see #listIterator(int) |
| */ |
| protected List getChildren() { |
| return children; |
| } |
| |
| // Documentation copied from interface |
| public int size() { |
| return getChildren().size(); |
| } |
| |
| /** |
| * Adds a child operation to me. This should only be done before I am |
| * executed. Has no effect if I already contain this operation as a child. |
| * |
| * @param operation |
| * a new child operation |
| * |
| * @throws IllegalStateException |
| * if I have already been successfully executed |
| */ |
| public void add(IUndoableOperation operation) { |
| |
| assertNotExecuted(); |
| |
| if (!getChildren().contains(operation)) { |
| getChildren().add(operation); |
| didAdd(operation); |
| } |
| } |
| |
| /** |
| * Updates my undo contexts for the addition of a new child operation. |
| * |
| * @param operation |
| * a new child operation |
| */ |
| private void didAdd(IUndoableOperation operation) { |
| IUndoContext[] childContexts = operation.getContexts(); |
| |
| for (int i = 0; i < childContexts.length; i++) { |
| |
| if (!hasContext(childContexts[i])) { |
| addContext(childContexts[i]); |
| } |
| } |
| } |
| |
| /** |
| * Removes a child operation from me. This should only be done before I am |
| * executed. Has no effect if I do not contain this operation as a child. |
| * <p> |
| * <b>Note</b> that I do not dispose an operation when it is removed from |
| * me. Although this is specified in the contract of the |
| * {@link ICompositeOperation} interface, this would not be correct, as I |
| * did not create that operation. |
| * </p> |
| * |
| * @param operation |
| * a child operation to remove |
| * |
| * @throws IllegalStateException |
| * if I have already been successfully executed |
| */ |
| public void remove(IUndoableOperation operation) { |
| |
| assertNotExecuted(); |
| |
| if (getChildren().remove(operation)) { |
| didRemove(operation); |
| } |
| } |
| |
| /** |
| * Updates my undo contexts for the removal of a child operation. |
| * |
| * @param operation |
| * the child operation that was removed |
| */ |
| private void didRemove(IUndoableOperation operation) { |
| IUndoContext[] childContexts = operation.getContexts(); |
| |
| for (int i = 0; i < childContexts.length; i++) { |
| |
| if (!anyChildHasContext(childContexts[i])) { |
| removeContext(childContexts[i]); |
| } |
| } |
| } |
| |
| /** |
| * Queries whether any of my children has the specified context. |
| * |
| * @param ctx |
| * a context |
| * |
| * @return <code>false</code> if none of my children has the specified |
| * context; <code>true</code>, otherwise |
| */ |
| private boolean anyChildHasContext(IUndoContext ctx) { |
| boolean result = false; |
| |
| for (Iterator iter = iterator(); !result && iter.hasNext();) { |
| result = ((IUndoableOperation) iter.next()).hasContext(ctx); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * I can execute if I am not empty and all of my children can execute. |
| */ |
| public boolean canExecute() { |
| boolean result = !isEmpty() && super.canExecute(); |
| |
| for (Iterator iter = iterator(); result && iter.hasNext();) { |
| result = ((IUndoableOperation) iter.next()).canExecute(); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * I can redo if I am not empty and all my children can all be redone. |
| */ |
| public boolean canRedo() { |
| boolean result = !isEmpty() && super.canRedo(); |
| |
| for (Iterator iter = iterator(); result && iter.hasNext();) { |
| result = ((IUndoableOperation) iter.next()).canRedo(); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * I can undo if I am not empty and all my children can all be undone. |
| */ |
| public boolean canUndo() { |
| boolean result = !isEmpty() && super.canUndo(); |
| |
| for (Iterator iter = iterator(); result && iter.hasNext();) { |
| result = ((IUndoableOperation) iter.next()).canUndo(); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Disposes of each of my children. |
| */ |
| public void dispose() { |
| |
| for (Iterator iter = iterator(); iter.hasNext();) { |
| IUndoableOperation nextOperation = (IUndoableOperation) iter.next(); |
| nextOperation.dispose(); |
| } |
| } |
| |
| /** |
| * Adds <code>command</code> to the list of commands with which this |
| * composite is composed. |
| * |
| * @param operation |
| * The command with which to compose this command. |
| * @return <code>this</code>. |
| */ |
| public final ICommand compose(IUndoableOperation operation) { |
| |
| if (operation != null) { |
| add(operation); |
| } |
| return this; |
| } |
| |
| /** |
| * Appends a command onto a (possibly) existing composeite of commands. |
| * |
| * @param command an existing command, which may be a composite, a single |
| * command, or <code>null</code> |
| * @param next a command to append to the composite (may also be |
| * <code>null</code>, which produces no effect) |
| * |
| * @return the new composite, which is just <code>next</code> if |
| * <code>command</code> was <code>null</code> |
| */ |
| public static ICommand compose(ICommand command, ICommand next) { |
| if (command == null) { |
| return next; |
| } else if (next != null) { |
| return command.compose(next); |
| } else { |
| return command; |
| } |
| } |
| |
| /** |
| * Returns the simplest form of this command that is equivalent. This is |
| * useful for removing unnecessary nesting of commands. |
| * <P> |
| * If the composite has a single command, it returns the reduction of that |
| * single command. Otherwise, it returns itself. |
| * |
| * @return the simplest form of this command that is equivalent |
| */ |
| public ICommand reduce() { |
| switch (size()) { |
| case 1: |
| IUndoableOperation child = (IUndoableOperation) iterator().next(); |
| |
| if (child instanceof ICommand) { |
| ICommand cmd = ((ICommand) child).reduce(); |
| /* |
| * Propagate the label of the original command to the reduced. |
| */ |
| if (getLabel() != null && getLabel().length() > 0) { |
| cmd.setLabel(getLabel()); |
| } |
| return cmd; |
| } |
| } |
| return this; |
| } |
| |
| /** |
| * Returns a list containing all of the return values from |
| * <code>ICommand</code> children. |
| */ |
| protected List getReturnValues() { |
| |
| List returnValues = new ArrayList(); |
| |
| for (Iterator i = iterator(); i.hasNext();) { |
| IUndoableOperation operation = (IUndoableOperation) i.next(); |
| |
| if (operation instanceof ICommand) { |
| ICommand command = (ICommand) operation; |
| |
| CommandResult result = command.getCommandResult(); |
| |
| if (result != null) { |
| Object returnValue = result.getReturnValue(); |
| |
| if (returnValue != null) { |
| |
| if (getClass().isInstance(command)) { |
| // unwrap the values from other composites |
| if (returnValue != null |
| && returnValue instanceof Collection) { |
| returnValues.addAll((Collection) returnValue); |
| |
| } else { |
| returnValues.add(returnValue); |
| } |
| |
| } else { |
| returnValues.add(returnValue); |
| } |
| } |
| } |
| } |
| } |
| |
| return returnValues; |
| } |
| |
| /** |
| * Implements the execution logic by sequential execution of my children. |
| */ |
| protected CommandResult doExecuteWithResult( |
| IProgressMonitor progressMonitor, IAdaptable info) |
| throws ExecutionException { |
| |
| List result = new ArrayList(size()); |
| |
| progressMonitor.beginTask(getLabel(), size()); |
| |
| try { |
| |
| for (ListIterator iter = listIterator(); iter.hasNext();) { |
| IUndoableOperation next = (IUndoableOperation) iter.next(); |
| |
| try { |
| IStatus status = next.execute(new SubProgressMonitor( |
| progressMonitor, 1), info); |
| result.add(status); |
| int severity = status.getSeverity(); |
| |
| if (severity == IStatus.CANCEL || severity == IStatus.ERROR) { |
| |
| // Undo the operation to date, excluding the current |
| // child, and don't proceed |
| Trace |
| .trace( |
| CommonCorePlugin.getDefault(), |
| "Composite operation execution recovery: child command status is CANCEL or ERROR."); //$NON-NLS-1$ |
| // back-track over the operation that failed |
| iter.previous(); |
| unwindFailedExecute(iter, info); |
| break; |
| |
| } else if (progressMonitor.isCanceled()) { |
| // Undo the operation to date, including the current |
| // child, and don't proceed |
| Trace |
| .trace(CommonCorePlugin.getDefault(), |
| "Composite operation redo recovery: child command monitor is cancelled."); //$NON-NLS-1$ |
| |
| CommandResult cancelResult = CommandResult |
| .newCancelledCommandResult(); |
| result.add(cancelResult.getStatus()); |
| |
| unwindFailedExecute(iter, info); |
| break; |
| |
| } else { |
| progressMonitor.worked(1); |
| executed = true; |
| } |
| |
| } catch (ExecutionException e) { |
| // Undo the operation to date, and re-throw the exception |
| // back-track over the operation that failed |
| iter.previous(); |
| unwindFailedExecute(iter, info); |
| Trace.throwing(CommonCorePlugin.getDefault(), |
| CommonCoreDebugOptions.EXCEPTIONS_THROWING, |
| CompositeCommand.class, "execute", e); //$NON-NLS-1$ |
| throw e; |
| } |
| } |
| |
| } finally { |
| progressMonitor.done(); |
| } |
| |
| return new CommandResult(aggregateStatuses(result), getReturnValues()); |
| } |
| |
| /** |
| * Undoes the previous operations in the iterator. |
| * |
| * @param iter |
| * the execution iterator |
| * @param info |
| * the execution info |
| */ |
| private void unwindFailedExecute(ListIterator iter, IAdaptable info) { |
| |
| while (iter.hasPrevious()) { |
| // unwind the child operations |
| IUndoableOperation prev = (IUndoableOperation) iter.previous(); |
| if (!prev.canUndo()) { |
| // Can't unwind |
| Log.error(CommonCorePlugin.getDefault(), |
| CommonCoreStatusCodes.EXECUTE_RECOVERY_FAILED, |
| CommonCoreMessages.bind( |
| CommonCoreMessages.executeRecoveryFailed, |
| CommonCoreMessages.cannotUndoExecuted)); |
| break; |
| } |
| |
| try { |
| prev.undo(new NullProgressMonitor(), info); |
| |
| } catch (ExecutionException inner) { |
| Log.error(CommonCorePlugin.getDefault(), |
| CommonCoreStatusCodes.EXECUTE_RECOVERY_FAILED, |
| CommonCoreMessages.bind( |
| CommonCoreMessages.executeRecoveryFailed, inner |
| .getLocalizedMessage())); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * I redo by asking my children to redo, in forward order. |
| */ |
| protected CommandResult doRedoWithResult(IProgressMonitor progressMonitor, |
| IAdaptable info) |
| throws ExecutionException { |
| |
| final List result = new ArrayList(size()); |
| |
| progressMonitor.beginTask(getLabel(), size()); |
| |
| try { |
| |
| for (ListIterator iter = listIterator(); iter.hasNext();) { |
| IUndoableOperation next = (IUndoableOperation) iter.next(); |
| |
| try { |
| |
| IStatus status = next.redo(new SubProgressMonitor( |
| progressMonitor, 1), info); |
| result.add(status); |
| int severity = status.getSeverity(); |
| |
| if (severity == IStatus.CANCEL || severity == IStatus.ERROR) { |
| // Undo the operation to date, excluding the current |
| // child, and don't proceed |
| Trace |
| .trace(CommonCorePlugin.getDefault(), |
| "Composite operation redo recovery: child command status is CANCEL or ERROR."); //$NON-NLS-1$ |
| // back-track over the operation that failed |
| iter.previous(); |
| unwindFailedRedo(iter, info); |
| break; |
| |
| } else if (progressMonitor.isCanceled()) { |
| // Undo the operation to date, including the current |
| // child, and don't proceed |
| Trace |
| .trace(CommonCorePlugin.getDefault(), |
| "Composite operation redo recovery: child command monitor is cancelled."); //$NON-NLS-1$ |
| |
| CommandResult cancelResult = CommandResult |
| .newCancelledCommandResult(); |
| result.add(cancelResult.getStatus()); |
| |
| unwindFailedRedo(iter, info); |
| break; |
| |
| } else { |
| progressMonitor.worked(1); |
| executed = true; |
| } |
| |
| } catch (ExecutionException e) { |
| // Undo the operation to date, and re-throw the exception |
| // back-track over the operation that failed |
| iter.previous(); |
| unwindFailedRedo(iter, info); |
| Trace.throwing(CommonCorePlugin.getDefault(), |
| CommonCoreDebugOptions.EXCEPTIONS_THROWING, |
| CompositeCommand.class, "redo", e); //$NON-NLS-1$ |
| throw e; |
| } |
| } |
| |
| } finally { |
| progressMonitor.done(); |
| } |
| |
| return new CommandResult(aggregateStatuses(result), getReturnValues()); |
| } |
| |
| /** |
| * Undoes the previous operations in the iterator. |
| * |
| * @param iter |
| * the execution iterator |
| * @param info |
| * the execution info |
| */ |
| private void unwindFailedRedo(ListIterator iter, IAdaptable info) { |
| |
| while (iter.hasPrevious()) { |
| // unwind the child operations |
| IUndoableOperation prev = (IUndoableOperation) iter.previous(); |
| if (!prev.canUndo()) { |
| // Can't unwind |
| Log.error(CommonCorePlugin.getDefault(), |
| CommonCoreStatusCodes.REDO_RECOVERY_FAILED, |
| CommonCoreMessages.bind( |
| CommonCoreMessages.redoRecoveryFailed, |
| CommonCoreMessages.cannotUndo)); |
| break; |
| } |
| |
| try { |
| prev.undo(new NullProgressMonitor(), info); |
| |
| } catch (ExecutionException inner) { |
| Log.error(CommonCorePlugin.getDefault(), |
| CommonCoreStatusCodes.REDO_RECOVERY_FAILED, |
| CommonCoreMessages.bind( |
| CommonCoreMessages.redoRecoveryFailed, inner |
| .getLocalizedMessage())); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * I undo by asking my children to undo, in reverse order. |
| */ |
| protected CommandResult doUndoWithResult(IProgressMonitor progressMonitor, |
| IAdaptable info) |
| throws ExecutionException { |
| |
| final List result = new ArrayList(size()); |
| |
| progressMonitor.beginTask(getLabel(), size()); |
| |
| try { |
| |
| for (ListIterator iter = listIterator(size()); iter.hasPrevious();) { |
| IUndoableOperation prev = (IUndoableOperation) iter.previous(); |
| |
| try { |
| IStatus status = prev.undo(new SubProgressMonitor( |
| progressMonitor, 1), info); |
| result.add(status); |
| int severity = status.getSeverity(); |
| |
| if (severity == IStatus.CANCEL || severity == IStatus.ERROR) { |
| // Redo the operation to date, excluding the current |
| // child, and don't proceed |
| Trace |
| .trace(CommonCorePlugin.getDefault(), |
| "Composite operation undo recovery: child command status is CANCEL or ERROR."); //$NON-NLS-1$ |
| // back-track over the operation that failed or was |
| // cancelled |
| iter.next(); |
| unwindFailedUndo(iter, info); |
| break; |
| |
| } else if (progressMonitor.isCanceled()) { |
| // Redo the operation to date, including the current |
| // child, and don't proceed |
| Trace |
| .trace(CommonCorePlugin.getDefault(), |
| "Composite operation undo recovery: child command monitor is cancelled."); //$NON-NLS-1$ |
| |
| CommandResult cancelResult = CommandResult |
| .newCancelledCommandResult(); |
| result.add(cancelResult.getStatus()); |
| |
| unwindFailedUndo(iter, info); |
| break; |
| |
| } else { |
| progressMonitor.worked(1); |
| executed = true; |
| } |
| |
| } catch (ExecutionException e) { |
| // Redo the operation to date, and re-throw the exception |
| // back-track over the operation that failed |
| iter.next(); |
| unwindFailedUndo(iter, info); |
| Trace.throwing(CommonCorePlugin.getDefault(), |
| CommonCoreDebugOptions.EXCEPTIONS_THROWING, |
| CompositeCommand.class, "undo", e); //$NON-NLS-1$ |
| throw e; |
| } |
| } |
| |
| } finally { |
| progressMonitor.done(); |
| } |
| |
| return new CommandResult(aggregateStatuses(result), getReturnValues()); |
| } |
| |
| /** |
| * Redoes the next operations in the iterator. |
| * |
| * @param iter |
| * the execution iterator |
| * @param info |
| * the execution info |
| */ |
| private void unwindFailedUndo(ListIterator iter, IAdaptable info) { |
| |
| while (iter.hasNext()) { |
| // unwind the child operations |
| IUndoableOperation next = (IUndoableOperation) iter.next(); |
| if (!next.canRedo()) { |
| // Can't unwind |
| Log.error(CommonCorePlugin.getDefault(), |
| CommonCoreStatusCodes.UNDO_RECOVERY_FAILED, |
| CommonCoreMessages.bind( |
| CommonCoreMessages.undoRecoveryFailed, |
| CommonCoreMessages.cannotRedo)); |
| break; |
| } |
| |
| try { |
| next.redo(new NullProgressMonitor(), info); |
| |
| } catch (ExecutionException inner) { |
| Log.error(CommonCorePlugin.getDefault(), |
| CommonCoreStatusCodes.UNDO_RECOVERY_FAILED, |
| CommonCoreMessages.bind( |
| CommonCoreMessages.undoRecoveryFailed, inner |
| .getLocalizedMessage())); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Creates a suitable aggregate from these statuses. If there are no |
| * statuses to aggregate, then an OK status is returned. If there is a |
| * single status to aggregate, then it is returned. Otherwise, a |
| * multi-status is returned with the provided statuses as children. |
| * |
| * @param statuses |
| * the statuses to aggregate. May have zero, one, or more |
| * elements (all must be {@link IStatus}es) |
| * |
| * @return the multi-status |
| */ |
| protected IStatus aggregateStatuses(List statuses) { |
| final IStatus result; |
| |
| if (statuses.isEmpty()) { |
| result = Status.OK_STATUS; |
| } else if (statuses.size() == 1) { |
| result = ((IStatus) statuses.get(0)); |
| } else { |
| // find the most severe status, to use its plug-in, code, and |
| // message |
| IStatus[] statusArray = (IStatus[]) statuses |
| .toArray(new IStatus[statuses.size()]); |
| |
| IStatus worst = statusArray[0]; |
| for (int i = 1; i < statusArray.length; i++) { |
| if (statusArray[i].getSeverity() > worst.getSeverity()) { |
| worst = statusArray[i]; |
| } |
| } |
| |
| result = new MultiStatus(worst.getPlugin(), worst.getCode(), |
| statusArray, worst.getMessage(), null); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Answers whether or not I have been executed. |
| * |
| * @return <code>true</code> if I have been executed, <code>false</code> |
| * otherwise. |
| */ |
| protected final boolean isExecuted() { |
| return executed; |
| } |
| |
| /** |
| * Asserts that I have not yet been executed. Changes to my children are not |
| * permitted after I have been executed. |
| */ |
| protected final void assertNotExecuted() { |
| if (isExecuted()) { |
| IllegalStateException exc = new IllegalStateException( |
| "Operation already executed"); //$NON-NLS-1$ |
| Trace.throwing(CommonCorePlugin.getDefault(), |
| CommonCoreDebugOptions.EXCEPTIONS_THROWING, |
| CompositeCommand.class, "assertNotExecuted", exc); //$NON-NLS-1$ |
| throw exc; |
| } |
| } |
| |
| /** |
| * Returns a list containing all of the affected files from |
| * <code>ICommand</code> children. |
| */ |
| public List getAffectedFiles() { |
| |
| HashSet result = new HashSet(); |
| |
| for (Iterator i = iterator(); i.hasNext();) { |
| IUndoableOperation nextOperation = (IUndoableOperation) i.next(); |
| |
| if (nextOperation instanceof ICommand) { |
| List nextAffected = ((ICommand) nextOperation) |
| .getAffectedFiles(); |
| |
| if (nextAffected != null) { |
| result.addAll(nextAffected); |
| } |
| } |
| } |
| return new ArrayList(result); |
| } |
| |
| /** |
| * Obtains an iterator to traverse my child operations. Removing children |
| * via this iterator correctly maintains my undo contexts. |
| * |
| * @return an iterator of my children |
| */ |
| public Iterator iterator() { |
| return new ChildIterator(); |
| } |
| |
| /** |
| * Obtains an iterator to traverse my child operations in either direction. |
| * Adding and removing children via this iterator correctly maintains my |
| * undo contexts. |
| * <p> |
| * <b>Note</b> that, unlike list iterators generally, this implementation |
| * does not permit the addition of an operation that I already contain (the |
| * composite does not permit duplicates). Moreover, only |
| * {@link IUndoableOperation}s may be added, otherwise |
| * <code>ClassCastException</code>s will result. |
| * </p> |
| * |
| * @return an iterator of my children |
| */ |
| public ListIterator listIterator() { |
| return new ChildListIterator(0); |
| } |
| |
| /** |
| * Obtains an iterator to traverse my child operations in either direction, |
| * starting from the specified <code>index</code>. Adding and removing |
| * children via this iterator correctly maintains my undo contexts. |
| * <p> |
| * <b>Note</b> that, unlike list iterators generally, this implementation |
| * does not permit the addition of an operation that I already contain (the |
| * composite does not permit duplicates). Moreover, only |
| * {@link IUndoableOperation}s may be added, otherwise |
| * <code>ClassCastException</code>s will result. |
| * </p> |
| * |
| * @param index |
| * the index in my children at which to start iterating |
| * |
| * @return an iterator of my children |
| */ |
| public ListIterator listIterator(int index) { |
| return new ChildListIterator(index); |
| } |
| |
| /** |
| * Custom iterator implementation that maintains my undo contexts correctly |
| * when elements are removed. |
| * |
| * @author ldamus |
| */ |
| private class ChildIterator |
| implements Iterator { |
| |
| protected Object last; |
| |
| protected final ListIterator iter; |
| |
| ChildIterator() { |
| this(0); |
| } |
| |
| ChildIterator(int index) { |
| iter = getChildren().listIterator(index); |
| } |
| |
| public void remove() { |
| assertNotExecuted(); |
| |
| iter.remove(); |
| didRemove((IUndoableOperation) last); |
| last = null; |
| } |
| |
| public Object next() { |
| last = iter.next(); |
| return last; |
| } |
| |
| public boolean hasNext() { |
| return iter.hasNext(); |
| } |
| } |
| |
| /** |
| * Custom list-iterator implementation that maintains my undo contexts |
| * correctly, as well as uniqueness of the list contents. |
| * |
| * @author ldamus |
| */ |
| private class ChildListIterator |
| extends ChildIterator |
| implements ListIterator { |
| |
| ChildListIterator(int index) { |
| super(index); |
| } |
| |
| public void add(Object o) { |
| assertNotExecuted(); |
| |
| if (!getChildren().contains(o)) { |
| iter.add(o); |
| didAdd((IUndoableOperation) o); |
| } |
| } |
| |
| public void set(Object o) { |
| assertNotExecuted(); |
| |
| if (!getChildren().contains(o)) { |
| didRemove((IUndoableOperation) last); |
| iter.set(o); |
| last = o; |
| didAdd((IUndoableOperation) o); |
| } |
| } |
| |
| public int previousIndex() { |
| return iter.previousIndex(); |
| } |
| |
| public int nextIndex() { |
| return iter.nextIndex(); |
| } |
| |
| public Object previous() { |
| last = iter.previous(); |
| return last; |
| } |
| |
| public boolean hasPrevious() { |
| return iter.hasPrevious(); |
| } |
| } |
| |
| @Override |
| public CommandResult getCommandResult() { |
| |
| CommandResult commandResult = super.getCommandResult(); |
| if (commandResult == null) { |
| |
| List<IStatus> statusList = new ArrayList<IStatus>(size()); |
| |
| for (Iterator<?> i = iterator(); i.hasNext();) { |
| IUndoableOperation operation = (IUndoableOperation) i.next(); |
| |
| if (operation instanceof ICommand) { |
| ICommand command = (ICommand) operation; |
| |
| CommandResult result = command.getCommandResult(); |
| if (result != null) { |
| statusList.add(result.getStatus()); |
| } |
| } |
| } |
| |
| // Don't set the command explicitly since the intermediate command could |
| // have children added later. |
| return new CommandResult(aggregateStatuses(statusList), |
| getReturnValues()); |
| } |
| return commandResult; |
| } |
| } |
