Eclipse EMF Model Transaction Development Guide (Galileo) - TransactionalEditingDomainImpl (EMF Model Transaction Javadoc)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

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:: EditingDomain, InternalTransactionalEditingDomain, TransactionalEditingDomain, TransactionalEditingDomain.DefaultOptions, Adaptable

public class TransactionalEditingDomainImpl
extends AdapterFactoryEditingDomain
implements InternalTransactionalEditingDomain, Adaptable, TransactionalEditingDomain.DefaultOptions
extends 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

AdapterFactoryEditingDomain.AdapterFactoryEditingDomainResourceSet, AdapterFactoryEditingDomain.DomainTreeIterator< E>, 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 ( AdapterFactory adapterFactory)
          Initializes me with my adapter factory and default implementations of a resource set and a command stack.

TransactionalEditingDomainImpl ( AdapterFactory adapterFactory, ResourceSet resourceSet)
          Initializes me with my adapter factory and a resource set, and a default command stack implementation.

TransactionalEditingDomainImpl ( AdapterFactory adapterFactory, TransactionalCommandStack stack)
          Initializes me with my adapter factory and a command stack, and a default resource set implementation.

TransactionalEditingDomainImpl ( AdapterFactory adapterFactory, TransactionalCommandStack stack, 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 ( 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 ( 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(
AdapterFactory adapterFactory,
                                      
TransactionalCommandStack stack,
                                      
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(
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(
AdapterFactory adapterFactory,
                                      
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(
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(
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(
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

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.eclipse.emf.transaction.impl Class TransactionalEditingDomainImpl

TransactionalEditingDomainImpl

TransactionalEditingDomainImpl

TransactionalEditingDomainImpl

TransactionalEditingDomainImpl

createChangeRecorder

getID

setID

getDebugID

addResourceSetListener

removeResourceSetListener

getTransactionalCommandStack

runExclusive

yield

startTransaction

getDebugID

getChangeRecorder

getValidator

setValidator

getPrecommitListeners

getAggregatePrecommitListeners

getPostcommitListeners

getActiveTransaction

activate

deactivate

precommit

postcommit

broadcastUnbatched

createPrivilegedRunnable

startPrivileged

endPrivileged

dispose

getUndoRedoOptions

getAdapter

getDefaultTransactionOptions

setDefaultTransactionOptions

setValidatorFactory

getValidatorFactory

getLifecycle

createLifecycle

getOptionMetadata

createOptionMetadataRegistry

org.eclipse.emf.transaction.impl
Class TransactionalEditingDomainImpl