## org.eclipse.emf.transaction.impl
Class AbstractTransactionalCommandStack

    java.lang.Object
      org.eclipse.emf.common.command.BasicCommandStack
          org.eclipse.emf.transaction.impl.AbstractTransactionalCommandStack

All Implemented Interfaces:
  org.eclipse.emf.common.command.CommandStack, InternalTransactionalCommandStack, TransactionalCommandStack

Direct Known Subclasses:
  TransactionalCommandStackImpl, WorkspaceCommandStackImpl

    public abstract class AbstractTransactionalCommandStack

extends org.eclipse.emf.common.command.BasicCommandStack
implements InternalTransactionalCommandStack

Partial implementation of the `TransactionalCommandStack` interface, useful for subclasses to define their specific handling of transactions and other concerns.

Since:
  1.1

Field Summary
`protected ExceptionHandler` `exceptionHandler`

Fields inherited from class org.eclipse.emf.common.command.BasicCommandStack
`commandList, listeners, mostRecentCommand, saveIndex, top`

Constructor Summary
`AbstractTransactionalCommandStack()` Initializes me.

Method Summary
`protected void` `basicExecute(org.eclipse.emf.common.command.Command command)` Provides access to the `BasicCommandStack` implementation of the `execute(Command)` method, as this class overrides it to delegate to the `TransactionalCommandStack.execute(Command, Map)` method.
`protected abstract void` `doExecute(org.eclipse.emf.common.command.Command command, Map<?,?> options)` Implemented by subclasses to perform the execution of the specified `command`.
`void` `execute(org.eclipse.emf.common.command.Command command)` Redefines the inherited method by forwarding to the `TransactionalCommandStack.execute(Command, Map)` method.
`void` `execute(org.eclipse.emf.common.command.Command command, Map<?,?> options)` Default implementation delegates to the subclass implementation of `doExecute(Command, Map)`, handling the roll-back exception if the command is rolled back.
`InternalTransactionalEditingDomain` `getDomain()` Obtains the editing domain in which I create transactions.
`ExceptionHandler` `getExceptionHandler()` Obtains my exception handler.
`protected Map<?,?>` `getUndoRedoOptions()` Obtains my editing domain's default undo/redo transaction options.
`protected void` `handleError(Exception exception)` Extends the inherited method by first aborting the active transaction (if any) and passing the exception along to the registered exception handler (if any).
`protected void` `handleRollback(org.eclipse.emf.common.command.Command command, RollbackException rbe)` Handles the roll-back of the specified `command` execution.
`static Map<Object,Object>` `makeTriggerTransactionOptions(Map<?,?> options)` Customizes the specified `options` for the case of a transaction that executes trigger commands.
`protected void` `rollback(Transaction tx)` Ensures that the specified transaction is rolled back, first rolling back a nested transaction (if any).
`void` `setEditingDomain(InternalTransactionalEditingDomain domain)` Assigns the editing domain in which I create transactions.
`void` `setExceptionHandler(ExceptionHandler handler)` Sets an exception handler.

Methods inherited from class org.eclipse.emf.common.command.BasicCommandStack
`addCommandStackListener, canRedo, canUndo, flush, getMostRecentCommand, getRedoCommand, getUndoCommand, isSaveNeeded, notifyListeners, redo, removeCommandStackListener, saveIsDone, undo`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Methods inherited from interface org.eclipse.emf.transaction.impl.InternalTransactionalCommandStack
`createTransaction, dispose, executeTriggers`

Methods inherited from interface org.eclipse.emf.common.command.CommandStack
`addCommandStackListener, canRedo, canUndo, flush, getMostRecentCommand, getRedoCommand, getUndoCommand, redo, removeCommandStackListener, undo`

Field Detail

### exceptionHandler

    protected ExceptionHandler exceptionHandler

Constructor Detail

### AbstractTransactionalCommandStack

    public AbstractTransactionalCommandStack()

  Initializes me.

Method Detail

### getDomain

    public InternalTransactionalEditingDomain getDomain()

  Description copied from interface: `InternalTransactionalCommandStack`
  Obtains the editing domain in which I create transactions.

  Specified by:
    `getDomain` in interface `InternalTransactionalCommandStack`
  Returns:
    my editing domain
  See Also:
    `InternalTransactionalCommandStack.createTransaction(Command, Map)`

### setEditingDomain

    public void setEditingDomain(InternalTransactionalEditingDomain domain)

  Description copied from interface: `InternalTransactionalCommandStack`
  Assigns the editing domain in which I create transactions.

  Specified by:
    `setEditingDomain` in interface `InternalTransactionalCommandStack`
  Parameters:
    `domain` - my editing domain
  See Also:
    `InternalTransactionalCommandStack.createTransaction(Command, Map)`

### rollback

    protected void rollback(Transaction tx)

  Ensures that the specified transaction is rolled back, first rolling back a nested transaction (if any).

  Parameters:
    `tx` - a transaction to roll back

### setExceptionHandler

    public void setExceptionHandler(ExceptionHandler handler)

  Description copied from interface: `TransactionalCommandStack`
  Sets an exception handler. This object will be notified when exceptions occur, but is not really expected to be able to do anything about them. Its intended purpose is to support an user feed-back mechanism appropriate to the environment.

  Specified by:
    `setExceptionHandler` in interface `TransactionalCommandStack`
  Parameters:
    `handler` - the exception handler to set

### getExceptionHandler

    public ExceptionHandler getExceptionHandler()

  Description copied from interface: `TransactionalCommandStack`
  Obtains my exception handler.

  Specified by:
    `getExceptionHandler` in interface `TransactionalCommandStack`
  Returns:
    my exception handler, or `null` if none
  See Also:
    `TransactionalCommandStack.setExceptionHandler(ExceptionHandler)`

### handleError

    protected void handleError(Exception exception)

  Extends the inherited method by first aborting the active transaction (if any) and passing the exception along to the registered exception handler (if any).

  Overrides:
    `handleError` in class `org.eclipse.emf.common.command.BasicCommandStack`

### execute

    public void execute(org.eclipse.emf.common.command.Command command,
                        Map<?,?> options)
                 throws InterruptedException,
                        RollbackException

  Default implementation delegates to the subclass implementation of `doExecute(Command, Map)`, handling the roll-back exception if the command is rolled back. Note that `doExecute()` is only called if the command is executable.

  Specified by:
    `execute` in interface `TransactionalCommandStack`
  Parameters:
    `command` - the command to execute
    `options` - the options to apply to the command's transaction, or `null` to select the defaults
  Throws:
    `InterruptedException` - if the current thread is interrupted while waiting to start a read/write transaction for the command execution
    `RollbackException` - if the changes performed by the command are rolled back by validation of the transaction

### doExecute

    protected abstract void doExecute(org.eclipse.emf.common.command.Command command,
                                      Map<?,?> options)
                               throws InterruptedException,
                                      RollbackException

  Implemented by subclasses to perform the execution of the specified `command`. Invoked by the `execute(Command, Map)` method.

  Parameters:
    `command` - the command to execute
    `options` - the transaction options to apply to execution of the command
  Throws:
    `InterruptedException` - if the current thread is interrupted while waiting to start the transaction
    `RollbackException` - if the execution of the command is rolled back

### handleRollback

    protected void handleRollback(org.eclipse.emf.common.command.Command command,
                                  RollbackException rbe)

  Handles the roll-back of the specified `command` execution. This default implementation disposes the command and notifies command-stack listeners so that they may get the latest information, in case they were already notified of command execution, for example.

  Parameters:
    `command` - the command whose execution was rolled back (may be `null` if not known)
    `rbe` - the roll-back exception (may be `null` if no exception is to be thrown)

### execute

    public void execute(org.eclipse.emf.common.command.Command command)

  Redefines the inherited method by forwarding to the `TransactionalCommandStack.execute(Command, Map)` method. Any checked exception thrown by that method is handled by `handleError(Exception)` but is not propagated.

  Specified by:
    `execute` in interface `org.eclipse.emf.common.command.CommandStack`
  Overrides:
    `execute` in class `org.eclipse.emf.common.command.BasicCommandStack`

### basicExecute

    protected void basicExecute(org.eclipse.emf.common.command.Command command)

  Provides access to the `BasicCommandStack` implementation of the `execute(Command)` method, as this class overrides it to delegate to the `TransactionalCommandStack.execute(Command, Map)` method.

  Parameters:
    `command` - the command to execute

### getUndoRedoOptions

    protected Map<?,?> getUndoRedoOptions()

  Obtains my editing domain's default undo/redo transaction options.

  Returns:
    my editing domain's transaction options for undo/redo

### makeTriggerTransactionOptions

    public static final Map<Object,Object> makeTriggerTransactionOptions(Map<?,?> options)

  Customizes the specified `options` for the case of a transaction that executes trigger commands. The original map is not affected.

  Parameters:
    `options` - a client-supplied options map
  Returns:
    a derived map of options suitable for trigger transactions

Copyright 2002, 2007 IBM Corporation and others. All Rights Reserved.