/******************************************************************************
* 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.emf.commands.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.Map;
import org.eclipse.core.commands.operations.IOperationApprover;
import org.eclipse.core.commands.operations.IUndoableOperation;
import org.eclipse.core.commands.operations.OperationHistoryFactory;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.workspace.AbstractEMFOperation;
import org.eclipse.emf.workspace.CompositeEMFOperation;
import org.eclipse.gmf.runtime.common.core.command.CommandResult;
import org.eclipse.gmf.runtime.common.core.command.ICommand;
import org.eclipse.gmf.runtime.common.core.command.ICompositeCommand;
import org.eclipse.gmf.runtime.common.core.internal.command.ICommandWithSettableResult;
import org.eclipse.gmf.runtime.common.core.util.StringStatics;
/**
* An undoable operation that is composed of child {@link IUndoableOperation}s
* that are expected to modify EMF model resources.
* <p>
* The operation provides a list of {@link IFile}s that are expected to be
* modified when the operation is executed, undone or redone. An
* {@link IOperationApprover} is registered with the
* {@link OperationHistoryFactory#getOperationHistory()} to validate the
* modification to these resources.
* <P>
* This class is meant to be instantiated by clients.
*
* @author ldamus
*/
public class CompositeTransactionalCommand
extends CompositeEMFOperation
implements ICompositeCommand, ICommandWithSettableResult {
private CommandResult commandResult;
/**
* Initializes me with the editing domain in which I am making model changes
* and a label.
*
* @param domain
* my editing domain
* @param label
* my user-readable label, should never be <code>null</code>.
*/
public CompositeTransactionalCommand(TransactionalEditingDomain domain,
String label) {
super(domain, (label == null) ? StringStatics.BLANK : label);
}
/**
* Initializes me with the editing domain, a label, and transaction options.
*
* @param domain
* my editing domain
* @param label
* my user-readable label, should never be <code>null</code>.
* @param options
* for the transaction in which I execute myself, or
* <code>null</code> for the default options
*/
public CompositeTransactionalCommand(TransactionalEditingDomain domain,
String label, Map options) {
super(domain, (label == null) ? StringStatics.BLANK : label, options);
}
/**
* Initializes me with the editing domain, a label, and child operations.
*
* @param domain
* my editing domain
* @param label
* my user-readable label, should never be <code>null</code>.
* @param children
* a list of operations to compose
*/
public CompositeTransactionalCommand(TransactionalEditingDomain domain,
String label, List children) {
super(domain, (label == null) ? StringStatics.BLANK : label, children);
}
/**
* Initializes me with the editing domain, a label, and child operations,
* and transaction options.
*
* @param domain
* my editing domain
* @param label
* my user-readable label, should never be <code>null</code>.
* @param children
* a list of operations to compose
* @param options
* for the transaction in which I execute myself, or
* <code>null</code> for the default options
*/
public CompositeTransactionalCommand(TransactionalEditingDomain domain,
String label, List children, Map options) {
super(domain, (label == null) ? StringStatics.BLANK : label, children, options);
}
/**
* Returns the {@link IFile}s for resources that may be modified when the
* operation is executed, undone or redone.
*/
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);
}
public CommandResult 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(super.aggregateStatuses(statusList),
getReturnValues());
}
return commandResult;
}
/**
* Sets the command result.
*
* @param result
* the new result for this command.
*/
protected void setResult(CommandResult result) {
this.commandResult = result;
}
/**
* 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;
}
/**
* Overrides the superclass implementation to set the command result.
*/
protected IStatus aggregateStatuses(List statuses) {
IStatus aggregate = super.aggregateStatuses(statuses);
setResult(new CommandResult(aggregate, getReturnValues()));
return aggregate;
}
// Documentation copied from the interface
public final ICommand compose(IUndoableOperation operation) {
if (operation != null) {
add(operation);
}
return this;
}
/**
* 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 0:
return this;
case 1:
IUndoableOperation child = (IUndoableOperation) iterator()
.next();
if (child instanceof ICommand &&
child instanceof AbstractEMFOperation) {
// return the single command if is a kind of EMF operation;
// otherwise this composite will be returned to preserve the
// EMF transaction behaviour.
return ((ICommand) child).reduce();
}
default:
if (!isTransactionNestingEnabled()) {
List children = getChildren();
IUndoableOperation[] opChildren = (IUndoableOperation[]) children
.toArray(new IUndoableOperation[children.size()]);
children.clear();
for (int i = 0; i < opChildren.length; ++i) {
doReduce(opChildren[i], children);
}
}
}
return this;
}
private void doReduce(IUndoableOperation operation, List children) {
if (operation instanceof CompositeEMFOperation) {
for (Iterator i = ((CompositeEMFOperation) operation).iterator(); i.hasNext();) {
doReduce((IUndoableOperation) i.next(), children);
}
} else {
children.add(operation);
}
}
/**
* 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;
}
/**
* I can execute if I am not empty and all of my children can execute.
*/
public boolean canExecute() {
return !isEmpty() && super.canExecute();
}
/**
* I can redo if I am not empty and all my children can all be redone.
*/
public boolean canRedo() {
return !isEmpty() && super.canRedo();
}
/**
* I can undo if I am not empty and all my children can all be undone.
*/
public boolean canUndo() {
return !isEmpty() && super.canUndo();
}
/**
* Internal method to set the command result.
*
* @param result CommandResult to set
* @deprecated internal API
*/
public void internalSetResult(CommandResult result) {
this.commandResult = result;
}
}