Package org.eclipse.emf.cdo.spi.server

## Class ObjectWriteAccessHandler

- java.lang.Object
- - org.eclipse.emf.cdo.spi.server.ObjectWriteAccessHandler

- All Implemented Interfaces:
    `IRepository.Handler`, `IRepository.WriteAccessHandler`

      public class ObjectWriteAccessHandler
      extends java.lang.Object
      implements IRepository.WriteAccessHandler

  If the meaning of this type isn't clear, there really should be more of a description here...
  Since:
    4.0
  Author:
    Eike Stepper

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface org.eclipse.emf.cdo.server.IRepository.WriteAccessHandler

      `IRepository.WriteAccessHandler.TransactionValidationException`

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `ObjectWriteAccessHandler()` |
    `ObjectWriteAccessHandler​(boolean legacyModeEnabled)` | Deprecated. As of 4.2 the legacy mode is always enabled.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `protected IStoreAccessor.CommitContext` | `getCommitContext()` |
    `protected org.eclipse.emf.ecore.EObject[]` | `getDirtyObjects()` |
    `protected org.eclipse.emf.ecore.EObject[]` | `getNewObjects()` |
    `protected ITransaction` | `getTransaction()` |
    `protected CDOView` | `getView()` |
    `void` | `handleTransactionAfterCommitted​(ITransaction transaction, IStoreAccessor.CommitContext commitContext, org.eclipse.net4j.util.om.monitor.OMMonitor monitor)` | Provides a way to handle transactions after they have been committed to the backend store.
    `protected void` | `handleTransactionAfterCommitted​(org.eclipse.net4j.util.om.monitor.OMMonitor monitor)` |
    `void` | `handleTransactionBeforeCommitting​(ITransaction transaction, IStoreAccessor.CommitContext commitContext, org.eclipse.net4j.util.om.monitor.OMMonitor monitor)` | Provides a way to handle transactions that are to be committed to the backend store.
    `protected void` | `handleTransactionBeforeCommitting​(org.eclipse.net4j.util.om.monitor.OMMonitor monitor)` |
    `boolean` | `isLegacyModeEnabled()` | Deprecated. As of 4.2 the legacy mode is always enabled.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### ObjectWriteAccessHandler

          public ObjectWriteAccessHandler()

    - #### ObjectWriteAccessHandler

          @Deprecated
          public ObjectWriteAccessHandler​(boolean legacyModeEnabled)

      Deprecated.
      As of 4.2 the legacy mode is always enabled.

  - ### Method Detail

    - #### isLegacyModeEnabled

          @Deprecated
          public final boolean isLegacyModeEnabled()

      Deprecated.
      As of 4.2 the legacy mode is always enabled.

    - #### getCommitContext

          protected final IStoreAccessor.CommitContext getCommitContext()

    - #### getTransaction

          protected final ITransaction getTransaction()

    - #### getView

          protected final CDOView getView()

    - #### getNewObjects

          protected final org.eclipse.emf.ecore.EObject[] getNewObjects()

    - #### getDirtyObjects

          protected final org.eclipse.emf.ecore.EObject[] getDirtyObjects()

    - #### handleTransactionBeforeCommitting

          public final void handleTransactionBeforeCommitting​(ITransaction transaction,
                                                              IStoreAccessor.CommitContext commitContext,
                                                              org.eclipse.net4j.util.om.monitor.OMMonitor monitor)
                                                       throws java.lang.RuntimeException

      Description copied from interface: `IRepository.WriteAccessHandler`
      Provides a way to handle transactions that are to be committed to the backend store.
      Specified by:
        `handleTransactionBeforeCommitting` in interface `IRepository.WriteAccessHandler`
      Parameters:
        `transaction` - The transaction that is going to be committed.
        `commitContext` - The context of the commit operation that is to be executed against the backend store. The context can be used to introspect all aspects of the current commit operation. Note that you must call `commitContext.modify()` if you plan to alter the internal state of the commit context!
        `monitor` - A monitor that should be used by the implementor to avoid timeouts.
      Throws:
        `IRepository.WriteAccessHandler.TransactionValidationException` - to indicate that the commit operation must not be executed against the backend store because some semantic validation checks failed. The message should describe the validation failure and will be passed through to the client
        `java.lang.RuntimeException` - to indicate that the commit operation must not be executed against the backend store. This exception will be visible at the client side!

    - #### handleTransactionAfterCommitted

          public final void handleTransactionAfterCommitted​(ITransaction transaction,
                                                            IStoreAccessor.CommitContext commitContext,
                                                            org.eclipse.net4j.util.om.monitor.OMMonitor monitor)

      Description copied from interface: `IRepository.WriteAccessHandler`
      Provides a way to handle transactions after they have been committed to the backend store.
      Specified by:
        `handleTransactionAfterCommitted` in interface `IRepository.WriteAccessHandler`
      Parameters:
        `transaction` - The transaction that has been committed.
        `commitContext` - The context of the commit operation that was executed against the backend store. The context can be used to introspect all aspects of the current commit operation. Note that you must not alter the internal state of the commit context in any way!
        `monitor` - A monitor that should be used by the implementor to avoid timeouts.

    - #### handleTransactionBeforeCommitting

          protected void handleTransactionBeforeCommitting​(org.eclipse.net4j.util.om.monitor.OMMonitor monitor)
                                                    throws java.lang.RuntimeException

      Throws:
        `java.lang.RuntimeException`

    - #### handleTransactionAfterCommitted

          protected void handleTransactionAfterCommitted​(org.eclipse.net4j.util.om.monitor.OMMonitor monitor)