Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Programming
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Databases
Mail Systems
openSolaris
Eclipse Documentation
Techotopia.com
Virtuatopia.com

How To Guides
Virtualization
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Windows
Problem Solutions
Privacy Policy

  




 

 


org.eclipse.emf.transaction.impl
Class TransactionalEditingDomainImpl

java.lang.Object
  extended by 

org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain
      extended by 
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

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:

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

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


 
 
  Published under the terms of the Eclipse Public License Version 1.0 ("EPL") Design by Interspire