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

    java.lang.Object
      org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain
          org.eclipse.emf.transaction.impl.TransactionalEditingDomainImpl

All Implemented Interfaces:
  org.eclipse.emf.edit.domain.EditingDomain, InternalTransactionalEditingDomain, TransactionalEditingDomain, TransactionalEditingDomain.DefaultOptions, Adaptable

    public class TransactionalEditingDomainImpl

extends org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain
implements InternalTransactionalEditingDomain, Adaptable, TransactionalEditingDomain.DefaultOptions

The default implementation of the transactional editing domain.

Since 1.2, this class implements the `Adaptable` interface to adapt to the following optional API:

- `TransactionalEditingDomain.DefaultOptions`
- `TransactionalEditingDomain.Lifecycle` (since 1.3)
- `Transaction.Option.Registry` (since 1.3)

Nested Class Summary
`static class` `TransactionalEditingDomainImpl.FactoryImpl` Default implementation of a transaction editing domain factory.
`protected class` `TransactionalEditingDomainImpl.LifecycleImpl` Default implementation of the `InternalLifecycle` protocol.
`static class` `TransactionalEditingDomainImpl.RegistryImpl` Implementation of the global editing domain registry.
`static class` `TransactionalEditingDomainImpl.ValidatorFactoryImpl` Default implementation of the validator factory

Nested classes/interfaces inherited from class org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain
`org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain.AdapterFactoryEditingDomainResourceSet, org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain.DomainTreeIterator<E>, org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain.EditingDomainProvider`

Nested classes/interfaces inherited from interface org.eclipse.emf.transaction.TransactionalEditingDomain
`TransactionalEditingDomain.DefaultOptions, TransactionalEditingDomain.Factory, TransactionalEditingDomain.Lifecycle, TransactionalEditingDomain.Registry`

Field Summary

Fields inherited from class org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain
`adapterFactory, clipboard, commandStack, optimizeCopy, resourceSet, resourceToReadOnlyMap`

Constructor Summary
`TransactionalEditingDomainImpl(org.eclipse.emf.common.notify.AdapterFactory adapterFactory)` Initializes me with my adapter factory and default implementations of a resource set and a command stack.
`TransactionalEditingDomainImpl(org.eclipse.emf.common.notify.AdapterFactory adapterFactory, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)` Initializes me with my adapter factory and a resource set, and a default command stack implementation.
`TransactionalEditingDomainImpl(org.eclipse.emf.common.notify.AdapterFactory adapterFactory, TransactionalCommandStack stack)` Initializes me with my adapter factory and a command stack, and a default resource set implementation.
`TransactionalEditingDomainImpl(org.eclipse.emf.common.notify.AdapterFactory adapterFactory, TransactionalCommandStack stack, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)` Initializes me with my adapter factory, command stack, and resource set.

Method Summary
`void` `activate(InternalTransaction tx)` Activates (starts) the specified transaction.
`void` `addResourceSetListener(ResourceSetListener l)` Adds a resource set listener to me, to receive notifications of changes to the resource set when transactions commit.
`void` `broadcastUnbatched(org.eclipse.emf.common.notify.Notification notification)` Broadcasts the specified notification to listeners as a singleton list, in a situation where batching is not possible because events are occurring outside of any transaction context.
`protected TransactionChangeRecorder` `createChangeRecorder(org.eclipse.emf.ecore.resource.ResourceSet rset)` May be overridden by subclasses to create a custom change recorder implementation.
`protected TransactionalEditingDomainImpl.LifecycleImpl` `createLifecycle()` Creates a new lifecycle implementation.
`protected Transaction.OptionMetadata.Registry` `createOptionMetadataRegistry()` Creates a new transaction option metadata registry.
`RunnableWithResult<Object>` `createPrivilegedRunnable(Runnable runnable)` Wraps the specified `runnable` to give it access to the currently active transaction.
`void` `deactivate(InternalTransaction tx)` Deactivates the specified transaction.
`void` `dispose()` Disposes of this editing domain and any resources that it has allocated.
`void` `endPrivileged(PrivilegedRunnable<?> runnable)` Returns me to my previous owner, upon completion of the specified privileged runnable.
`InternalTransaction` `getActiveTransaction()` Obtains the transaction that currently has access to me, and whose thread of execution is active.

`

`<T> T`

`

`getAdapter(Class<? extends T> adapterType)`
Obtains an instance of the specified adapter type.

`protected ResourceSetListener[]` `getAggregatePrecommitListeners()` Obtains a copy of my aggregate pre-commit listener list as an array, for safe iteration that allows concurrent updates to the original list.
`TransactionChangeRecorder` `getChangeRecorder()` Obtains the change recorder that I use to track changes in my resource set.
`protected static String` `getDebugID(Transaction tx)` Obtains an ID suitable for display in debug/trace messages.
`protected static String` `getDebugID(TransactionalEditingDomain domain)` Obtains an ID suitable for display in debug/trace messages.
`Map<?,?>` `getDefaultTransactionOptions()` Obtains a read-only view of the editing domain's default transaction options.
`String` `getID()` Obtains my unique ID.
`protected TransactionalEditingDomainImpl.LifecycleImpl` `getLifecycle()` Obtains my lazily-created lifecycle implementation.
`protected Transaction.OptionMetadata.Registry` `getOptionMetadata()` Obtains my lazily-created transaction option metadata registry.
`protected ResourceSetListener[]` `getPostcommitListeners()` Obtains a copy of my post-commit listener list as an array, for safe iteration that allows concurrent updates to the original list.
`protected ResourceSetListener[]` `getPrecommitListeners()` Obtains a copy of my pre-commit listener list as an array, for safe iteration that allows concurrent updates to the original list.
`protected InternalTransactionalCommandStack` `getTransactionalCommandStack()` Obtains my command stack as the internal interface.
`Map<Object,Object>` `getUndoRedoOptions()` Retrieves the undo/redo options that should be used when creating transactions.
`TransactionValidator` `getValidator()` Gets the validator that transactions should use to validate themselves upon committing.
`TransactionValidator.Factory` `getValidatorFactory()` Obtains the factory that this transactional editing domain uses to create validators for transaction validation.
`protected void` `postcommit(InternalTransaction tx)` Performs post-commit processing of the specified transaction.
`void` `precommit(InternalTransaction tx)` Performs the pre-commit notifications and processing of trigger comamnds.
`void` `removeResourceSetListener(ResourceSetListener l)` Removes a resource set listener from me.
`Object` `runExclusive(Runnable read)` Runs an operation that requires exclusive access to my resource set, for reading.
`void` `setDefaultTransactionOptions(Map<?,?> options)` Sets the default transaction options.
`void` `setID(String id)` Sets my unique ID.
`protected void` `setValidator(TransactionValidator newValidator)`
`void` `setValidatorFactory(TransactionValidator.Factory validatorFactory)` Sets the factory to use when creating validators for transaction validation.
`void` `startPrivileged(PrivilegedRunnable<?> runnable)` Transfers ownership of this editing domain to the specified privileged runnable.
`InternalTransaction` `startTransaction(boolean readOnly, Map<?,?> options)` Creates and starts a new transaction.
`void` `yield()` Temporarily yields access to another read-only transaction.

Methods inherited from class org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain

`createCommand, createOverrideCommand, createResource, getAdapterFactory, getChildren, getClipboard, getCommandStack, getEditingDomainFor, getEditingDomainFor, getEditingDomainItemProviderFor, getNewChildDescriptors, getOptimizeCopy, getParent, getResourceSet, getResourceToReadOnlyMap, getRoot, getTreePath, getWrapper, getWrapper, isControllable, isControlled, isReadOnly, isReadOnlyURI, isStale, loadResource, resolve, setAdapterFactory, setClipboard, setOptimizeCopy, setResourceToReadOnlyMap, treeIterator, unwrap`

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.edit.domain.EditingDomain
`createCommand, createOverrideCommand, createResource, getChildren, getClipboard, getCommandStack, getNewChildDescriptors, getOptimizeCopy, getParent, getResourceSet, getRoot, getTreePath, isControllable, isReadOnly, loadResource, setClipboard, treeIterator`

Constructor Detail

### TransactionalEditingDomainImpl

    public TransactionalEditingDomainImpl(org.eclipse.emf.common.notify.AdapterFactory adapterFactory,
                                          TransactionalCommandStack stack,
                                          org.eclipse.emf.ecore.resource.ResourceSet resourceSet)

  Initializes me with my adapter factory, command stack, and resource set.

  Parameters:
    `adapterFactory` - my adapter factory
    `stack` - my command stack
    `resourceSet` - my resource set

### TransactionalEditingDomainImpl

    public TransactionalEditingDomainImpl(org.eclipse.emf.common.notify.AdapterFactory adapterFactory,
                                          TransactionalCommandStack stack)

  Initializes me with my adapter factory and a command stack, and a default resource set implementation.

  Parameters:
    `adapterFactory` - my adapter factory
    `stack` - my command stack

### TransactionalEditingDomainImpl

    public TransactionalEditingDomainImpl(org.eclipse.emf.common.notify.AdapterFactory adapterFactory,
                                          org.eclipse.emf.ecore.resource.ResourceSet resourceSet)

  Initializes me with my adapter factory and a resource set, and a default command stack implementation.

  Parameters:
    `adapterFactory` - my adapter factory
    `resourceSet` - my resource set

### TransactionalEditingDomainImpl

    public TransactionalEditingDomainImpl(org.eclipse.emf.common.notify.AdapterFactory adapterFactory)

  Initializes me with my adapter factory and default implementations of a resource set and a command stack.

  Parameters:
    `adapterFactory` - my adapter factory

Method Detail

### createChangeRecorder

    protected TransactionChangeRecorder createChangeRecorder(org.eclipse.emf.ecore.resource.ResourceSet rset)

  May be overridden by subclasses to create a custom change recorder implementation. Just creates a change recorder on the specified resource set and returns it.

  Parameters:
    `rset` - a resource set in which to record changes
  Returns:
    the new change recorder

### getID

    public final String getID()

  Description copied from interface: `TransactionalEditingDomain`
  Obtains my unique ID. This is the ID under which I am registered in the `TransactionalEditingDomain.Registry` (if I am registered).

  Specified by:
    `getID` in interface `TransactionalEditingDomain`
  Returns:
    my unique identifier
  See Also:
    `TransactionalEditingDomain.Registry.getEditingDomain(String)`

### setID

    public final void setID(String id)

  Description copied from interface: `TransactionalEditingDomain`
  Sets my unique ID. If I am currently registered in the `TransactionalEditingDomain.Registry`, then I am re-registered under this new ID. However, if I am registered statically on the `org.eclipse.emf.transaction.editingDomains` extension point, then my ID cannot be changed.

  Specified by:
    `setID` in interface `TransactionalEditingDomain`
  Parameters:
    `id` - my new unique identifier
  See Also:
    `TransactionalEditingDomain.getID()`, `TransactionalEditingDomain.Registry.add(String, TransactionalEditingDomain)`

### getDebugID

    protected static String getDebugID(TransactionalEditingDomain domain)

  Obtains an ID suitable for display in debug/trace messages.

  Parameters:
    `domain` - the editing domain for which to get the debug ID
  Returns:
    a debugging ID

### addResourceSetListener

    public void addResourceSetListener(ResourceSetListener l)

  Description copied from interface: `TransactionalEditingDomain`
  Adds a resource set listener to me, to receive notifications of changes to the resource set when transactions commit. This method has no effect if the specified listeners is already attached to me.

  Specified by:
    `addResourceSetListener` in interface `TransactionalEditingDomain`
  Parameters:
    `l` - a new resource set listener
  See Also:
    `ResourceSetListener.isPrecommitOnly()`, `ResourceSetListener.isPostcommitOnly()`

### removeResourceSetListener

    public void removeResourceSetListener(ResourceSetListener l)

  Description copied from interface: `TransactionalEditingDomain`
  Removes a resource set listener from me. This method has no effect if the listener is not currently attached to me.

  Specified by:
    `removeResourceSetListener` in interface `TransactionalEditingDomain`
  Parameters:
    `l` - a resource set listener to remove

### getTransactionalCommandStack

    protected InternalTransactionalCommandStack getTransactionalCommandStack()

  Obtains my command stack as the internal interface.

  Returns:
    the internal view of my command stack

### runExclusive

    public Object runExclusive(Runnable read)
                        throws InterruptedException

  Description copied from interface: `TransactionalEditingDomain`
  Runs an operation that requires exclusive access to my resource set, for reading. The specified runnable is executed in a read-only transaction. If the runnable implements the `RunnableWithResult` interface, then its result is returned after it completes. Moreover, (and this is a very good reason to implement this extension interface), if the transaction rolls back on commit, then the `RunnableWithResult` is provided with the error status indicating this condition. Even read-only transactions can roll back when, for example, another thread concurrently modifies the model (in violation of the transaction protocol), and it is important to know when corrupted data may have been read.

  Note that this method will block the current thread until exclusive access to the resource set can be obtained. However, it is safe to call this method on the Eclipse UI thread because special precaution is taken to ensure that liveness is maintained (using mechanisms built into the Job Manager).

  Note: Since the 1.2 release, the `TransactionUtil.runExclusive(TransactionalEditingDomain, RunnableWithResult)` utility provides type-safe execution of runnables returning results and should be preferred over this API.

  Specified by:
    `runExclusive` in interface `TransactionalEditingDomain`
  Parameters:
    `read` - a read-only operation to execute
  Returns:
    the result of the read operation if it is a `RunnableWithResult` and the transaction did not roll back; `null`, otherwise
  Throws:
    `InterruptedException` - if the current thread is interrupted while waiting for access to the resource set
  See Also:
    `TransactionUtil#runExclusive(RunnableWithResult)`, `Transaction.commit()`

### yield

    public void yield()

  Description copied from interface: `TransactionalEditingDomain`
  Temporarily yields access to another read-only transaction. The `TransactionalEditingDomain` supports any number of pseudo-concurrent read-only transactions. Transactions that are expected to be long-running should yield frequently, as a task running in a progress monitor is expected to check for cancellation frequently. However, there is a higher cost (in time) associated with yielding, so it should not be overdone.

  Only read-only transactions may yield, and only the transaction that is currently active in the editing domain may yield. The yielding transaction may be nested, but not within a read/write transaction at any depth.

  Upon yielding, some other read-only transaction that is attempting to start or to return from a yield will take control of the editing domain. Control is never yielded to a read/write transaction (not even to a read-only transaction nested in a read/write) because this would introduce dirty reads (transactions reading uncommitted changes). If there are no other read-only transactions to receive the transfer of control, then the call returns immediately. Otherwise, control is transferred in FIFO fashion to waiting transactions.

  Specified by:
    `yield` in interface `TransactionalEditingDomain`

### startTransaction

    public InternalTransaction startTransaction(boolean readOnly,
                                                Map<?,?> options)
                                         throws InterruptedException

  Description copied from interface: `InternalTransactionalEditingDomain`
  Creates and starts a new transaction. The current thread is blocked until I grant it exclusive access to my resource set.

  Specified by:
    `startTransaction` in interface `InternalTransactionalEditingDomain`
  Parameters:
    `readOnly` - `true` if the transaction is intended only to read the resource set; `false` if it will modify it
    `options` - the options to apply to the transaction (as specified by the `TransactionalCommandStack` interface
  Returns:
    the newly started transaction
  Throws:
    `InterruptedException` - if the current thread is interrupted while waiting for the transaction to start
  See Also:
    `InternalTransactionalEditingDomain.activate(InternalTransaction)`

### getDebugID

    protected static String getDebugID(Transaction tx)

  Obtains an ID suitable for display in debug/trace messages.

  Parameters:
    `tx` - the transaction for which to get the debug ID
  Returns:
    a debugging ID

### getChangeRecorder

    public TransactionChangeRecorder getChangeRecorder()

  Description copied from interface: `InternalTransactionalEditingDomain`
  Obtains the change recorder that I use to track changes in my resource set. Transactions are expected to use this change recorder as follows:
  - Start recording a fresh change description on starting and resuming
  - End recording (storing the change description) on committing and pausing
  - End recording (applying the change description) on rolling back

  Specified by:
    `getChangeRecorder` in interface `InternalTransactionalEditingDomain`
  Returns:
    my change recorder

### getValidator

    public TransactionValidator getValidator()

  Description copied from interface: `InternalTransactionalEditingDomain`
  Gets the validator that transactions should use to validate themselves upon committing. A transaction must ask the validator to validate after performing the pre-commit phase (if needed), unless it has the 'no validation' option.

  Specified by:
    `getValidator` in interface `InternalTransactionalEditingDomain`
  Returns:
    my transaction validator

### setValidator

    protected void setValidator(TransactionValidator newValidator)

### getPrecommitListeners

    protected final ResourceSetListener[] getPrecommitListeners()

  Obtains a copy of my pre-commit listener list as an array, for safe iteration that allows concurrent updates to the original list.

  Returns:
    my pre-commit listeners (as of the time of calling this method)

### getAggregatePrecommitListeners

    protected final ResourceSetListener[] getAggregatePrecommitListeners()

  Obtains a copy of my aggregate pre-commit listener list as an array, for safe iteration that allows concurrent updates to the original list.

  Returns:
    my aggregate pre-commit listeners (as of the time of calling this method)

### getPostcommitListeners

    protected final ResourceSetListener[] getPostcommitListeners()

  Obtains a copy of my post-commit listener list as an array, for safe iteration that allows concurrent updates to the original list.

  Returns:
    my post-commit listeners (as of the time of calling this method)

### getActiveTransaction

    public InternalTransaction getActiveTransaction()

  Description copied from interface: `InternalTransactionalEditingDomain`
  Obtains the transaction that currently has access to me, and whose thread of execution is active.

  Specified by:
    `getActiveTransaction` in interface `InternalTransactionalEditingDomain`
  Returns:
    my active transaction, or `null` if no transaction is currently active

### activate

    public void activate(InternalTransaction tx)
                  throws InterruptedException

  Description copied from interface: `InternalTransactionalEditingDomain`
  Activates (starts) the specified transaction. The current thread is blocked until the transaction is activated, at which point it will be my active transaction until it either yields (in the case of a read-only transaction) or closes.

  Note that only the thread that owns a transaction may activate it. Also, a nested read-write transaction cannot be activated if its parent transaction is read-only, unless the read-write transaction has the 'unprotected' option.

  Specified by:
    `activate` in interface `InternalTransactionalEditingDomain`
  Parameters:
    `tx` - the transaction to activate
  Throws:
    `InterruptedException` - if the current thread is interrupted while waiting for me to activate its transaction
  See Also:
    `InternalTransactionalEditingDomain.getActiveTransaction()`, `TransactionalEditingDomain.yield()`, `InternalTransactionalEditingDomain.startTransaction(boolean, Map)`, `InternalTransactionalEditingDomain.deactivate(InternalTransaction)`

### deactivate

    public void deactivate(InternalTransaction tx)

  Description copied from interface: `InternalTransactionalEditingDomain`
  Deactivates the specified transaction. After this method completes, the transaction is no longer my `active transaction`.

  The current thread must own the transaction that it is attempting to deactivate and this transaction must currently be my active transaction.

  Note that a transaction must ensure that this method is called when it closes, either by commit or by rollback, and at most once.

  Specified by:
    `deactivate` in interface `InternalTransactionalEditingDomain`
  Parameters:
    `tx` - the transaction to deactivate
  See Also:
    `InternalTransactionalEditingDomain.activate(InternalTransaction)`, `Transaction.commit()`, `Transaction.rollback()`

### precommit

    public void precommit(InternalTransaction tx)
                   throws RollbackException

  Description copied from interface: `InternalTransactionalEditingDomain`
  Performs the pre-commit notifications and processing of trigger comamnds. This method must be called at the beginning of the commit of a read/write transaction (not a read-only transaction), unless it has the 'no triggers' option.

  Specified by:
    `precommit` in interface `InternalTransactionalEditingDomain`
  Parameters:
    `tx` - the transaction that is being committed
  Throws:
    `RollbackException` - if any of the pre-commit listeners forces rollback of the transaction. The caller must honour this rollback request by actually rolling back the transaction
  See Also:
    `Transaction.commit()`, `Transaction.rollback()`, `ResourceSetListener.transactionAboutToCommit(org.eclipse.emf.transaction.ResourceSetChangeEvent)`

### postcommit

    protected void postcommit(InternalTransaction tx)

  Performs post-commit processing of the specified transaction. This consists of broadcasting the post-commit events to my resource set listeners.

  Parameters:
    `tx` - the transaction that has committed

### broadcastUnbatched

    public void broadcastUnbatched(org.eclipse.emf.common.notify.Notification notification)

  Description copied from interface: `InternalTransactionalEditingDomain`
  Broadcasts the specified notification to listeners as a singleton list, in a situation where batching is not possible because events are occurring outside of any transaction context. This can only occur in the case of read notifications.

  Specified by:
    `broadcastUnbatched` in interface `InternalTransactionalEditingDomain`
  Parameters:
    `notification` - the notification to send to resource set listeners
  See Also:
    `NotificationFilter.READ`, `ResourceSetListener`, `FilterManager.selectUnbatched(java.util.List, NotificationFilter)`

### createPrivilegedRunnable

    public final RunnableWithResult<Object> createPrivilegedRunnable(Runnable runnable)

  Description copied from interface: `TransactionalEditingDomain`
  Wraps the specified `runnable` to give it access to the currently active transaction. This is useful for two or more cooperating threads to share a transaction (read-only or read-write), executing code in the a `runnable` on one thread in the context of another thread's transaction.

  For example, in an Eclipse UI application, this might be used when a long-running task in a modal context thread needs to synchronously execute some operation on the UI thread, which operation needs to read or write the editing domain. e.g.,

           Runnable uiBoundAction = // ...
           Runnable privileged = domain.createPrivilegedRunnable(uiBoundAction);
           Display.syncExec(privileged);

  Note that it is critically important that this mechanism only be used to share a transaction with another thread synchronously. Or, more generally, during the execution of the privileged runnable, the thread that originally owned the transaction no longer does, and may not access the editing domain. Upon completion of the privileged runnable, the transaction is returned to its original owner.

  Also, the resulting runnable may only be executed while the currently active transaction remains active. Any attempt to execute the runnable after this transaction has committed or while a nested transaction is active will result in an `IllegalStateException`.

  Note: Since the 1.2 release, the `TransactionUtil.createPrivilegedRunnable(TransactionalEditingDomain, RunnableWithResult)` utility provides type-safe privileged access for runnables returning results and should be preferred over this API.

  Specified by:
    `createPrivilegedRunnable` in interface `TransactionalEditingDomain`
  Parameters:
    `runnable` - a runnable to execute in the context of the active transaction, on any thread
  Returns:
    the privileged runnable. If the wrapped `runnable` is a `RunnableWithResult`, then the privileged runnable will inherit its result when it completes
  See Also:
    `TransactionUtil.createPrivilegedRunnable(TransactionalEditingDomain, RunnableWithResult)`

### startPrivileged

    public void startPrivileged(PrivilegedRunnable<?> runnable)

  Description copied from interface: `InternalTransactionalEditingDomain`
  Transfers ownership of this editing domain to the specified privileged runnable.

  Specified by:
    `startPrivileged` in interface `InternalTransactionalEditingDomain`
  Parameters:
    `runnable` - the runnable whose thread is to borrow me

### endPrivileged

    public void endPrivileged(PrivilegedRunnable<?> runnable)

  Description copied from interface: `InternalTransactionalEditingDomain`
  Returns me to my previous owner, upon completion of the specified privileged runnable.

  Specified by:
    `endPrivileged` in interface `InternalTransactionalEditingDomain`
  Parameters:
    `runnable` - the runnable whose thread had borrowed me

### dispose

    public void dispose()

  Description copied from interface: `TransactionalEditingDomain`
  Disposes of this editing domain and any resources that it has allocated. Editing domains must be disposed when they are no longer in use, but only by the client that created them (in case of sharing of editing domains).

  Note that editing domains registered on the extension point may not be disposed.

  Specified by:
    `dispose` in interface `TransactionalEditingDomain`

### getUndoRedoOptions

    public Map<Object,Object> getUndoRedoOptions()

  Description copied from interface: `InternalTransactionalEditingDomain`
  Retrieves the undo/redo options that should be used when creating transactions.

  Specified by:
    `getUndoRedoOptions` in interface `InternalTransactionalEditingDomain`
  Returns:
    A map with undo/redo options.

### getAdapter

    public <T> T getAdapter(Class<? extends T> adapterType)

  Description copied from interface: `Adaptable`
  Obtains an instance of the specified adapter type.

  Specified by:
    `getAdapter` in interface `Adaptable`
  Type Parameters:
    `T` - the interface for which to get an adapter
  Parameters:
    `adapterType` - the required interface
  Returns:
    an instance of the required interface that adapts me, or `null` if I do not supply this interface

### getDefaultTransactionOptions

    public Map<?,?> getDefaultTransactionOptions()

  Description copied from interface: `TransactionalEditingDomain.DefaultOptions`
  Obtains a read-only view of the editing domain's default transaction options.

  Specified by:
    `getDefaultTransactionOptions` in interface `TransactionalEditingDomain.DefaultOptions`
  Returns:
    my read-only map of transaction options

### setDefaultTransactionOptions

    public void setDefaultTransactionOptions(Map<?,?> options)

  Description copied from interface: `TransactionalEditingDomain.DefaultOptions`
  Sets the default transaction options. It is probably best to do this only when configuring a new editing domain, as inconsistent behaviour may result from changing the options while editing transactions are in progress.

  Specified by:
    `setDefaultTransactionOptions` in interface `TransactionalEditingDomain.DefaultOptions`
  Parameters:
    `options` - the new options. The options are copied from the map

### setValidatorFactory

    public void setValidatorFactory(TransactionValidator.Factory validatorFactory)

  Sets the factory to use when creating validators for transaction validation.

  Parameters:
    `validatorFactory` - the factory to set
  Since:
    1.1

### getValidatorFactory

    public TransactionValidator.Factory getValidatorFactory()

  Obtains the factory that this transactional editing domain uses to create validators for transaction validation.

  If the validator factory has yet to be initialized, it is initialized using the default validator factory.

  Returns:
    the requested validator factory
  Since:
    1.1

### getLifecycle

    protected final TransactionalEditingDomainImpl.LifecycleImpl getLifecycle()

  Obtains my lazily-created lifecycle implementation.

  Returns:
    my lifecycle
  Since:
    1.3

### createLifecycle

    protected TransactionalEditingDomainImpl.LifecycleImpl createLifecycle()

  Creates a new lifecycle implementation. Subclasses may override to create their own implementation.

  Returns:
    a new lifecycle
  Since:
    1.3

### getOptionMetadata

    protected final Transaction.OptionMetadata.Registry getOptionMetadata()

  Obtains my lazily-created transaction option metadata registry.

  Returns:
    my option metadata registry
  Since:
    1.3

### createOptionMetadataRegistry

    protected Transaction.OptionMetadata.Registry createOptionMetadataRegistry()

  Creates a new transaction option metadata registry. Subclasses may override to create their own implementation, although it would hardly seem interesting to do so.

  Returns:
    a new option metadata registry
  Since:
    1.3

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