| /* |
| * Copyright (c) 2011-2016, 2018, 2019 Eike Stepper (Loehne, Germany) and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Eike Stepper - initial API and implementation |
| * Simon McDuff - maintenance |
| * Maxime Porhel - maintenance |
| */ |
| package org.eclipse.emf.internal.cdo.view; |
| |
| import org.eclipse.emf.cdo.CDOObject; |
| import org.eclipse.emf.cdo.CDOState; |
| import org.eclipse.emf.cdo.common.branch.CDOBranch; |
| import org.eclipse.emf.cdo.common.branch.CDOBranchVersion; |
| import org.eclipse.emf.cdo.common.id.CDOID; |
| import org.eclipse.emf.cdo.common.id.CDOIDTemp; |
| import org.eclipse.emf.cdo.common.revision.CDORevisable; |
| import org.eclipse.emf.cdo.common.revision.CDORevision; |
| import org.eclipse.emf.cdo.common.revision.CDORevisionFactory; |
| import org.eclipse.emf.cdo.common.revision.CDORevisionKey; |
| import org.eclipse.emf.cdo.common.revision.delta.CDOFeatureDelta; |
| import org.eclipse.emf.cdo.common.revision.delta.CDOListFeatureDelta; |
| import org.eclipse.emf.cdo.common.revision.delta.CDORevisionDelta; |
| import org.eclipse.emf.cdo.common.revision.delta.CDOSetFeatureDelta; |
| import org.eclipse.emf.cdo.common.security.NoPermissionException; |
| import org.eclipse.emf.cdo.common.util.PartialCollectionLoadingNotSupportedException; |
| import org.eclipse.emf.cdo.spi.common.model.InternalCDOPackageInfo; |
| import org.eclipse.emf.cdo.spi.common.revision.InternalCDORevision; |
| import org.eclipse.emf.cdo.spi.common.revision.InternalCDORevisionCache; |
| import org.eclipse.emf.cdo.spi.common.revision.InternalCDORevisionDelta; |
| import org.eclipse.emf.cdo.spi.common.revision.InternalCDORevisionManager; |
| import org.eclipse.emf.cdo.transaction.CDOTransaction; |
| import org.eclipse.emf.cdo.transaction.CDOTransactionHandler1; |
| import org.eclipse.emf.cdo.transaction.CDOTransactionHandler1.WithUndo; |
| import org.eclipse.emf.cdo.transaction.CDOUndoDetector; |
| import org.eclipse.emf.cdo.util.CDOUtil; |
| import org.eclipse.emf.cdo.view.CDOInvalidationPolicy; |
| import org.eclipse.emf.cdo.view.CDOView; |
| |
| import org.eclipse.emf.internal.cdo.CDOObjectImpl; |
| import org.eclipse.emf.internal.cdo.bundle.OM; |
| import org.eclipse.emf.internal.cdo.object.CDOLegacyWrapper; |
| import org.eclipse.emf.internal.cdo.object.CDONotificationBuilder; |
| |
| import org.eclipse.net4j.util.ReflectUtil; |
| import org.eclipse.net4j.util.collection.Pair; |
| import org.eclipse.net4j.util.fsm.FiniteStateMachine; |
| import org.eclipse.net4j.util.fsm.ITransition; |
| import org.eclipse.net4j.util.om.trace.ContextTracer; |
| |
| import org.eclipse.emf.common.notify.NotificationChain; |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EPackage; |
| import org.eclipse.emf.ecore.EStructuralFeature; |
| import org.eclipse.emf.ecore.InternalEObject; |
| import org.eclipse.emf.ecore.impl.EStoreEObjectImpl; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.util.EContentsEList; |
| import org.eclipse.emf.spi.cdo.CDOSessionProtocol.CommitTransactionResult; |
| import org.eclipse.emf.spi.cdo.FSMUtil; |
| import org.eclipse.emf.spi.cdo.InternalCDOObject; |
| import org.eclipse.emf.spi.cdo.InternalCDOSavepoint; |
| import org.eclipse.emf.spi.cdo.InternalCDOSession; |
| import org.eclipse.emf.spi.cdo.InternalCDOTransaction; |
| import org.eclipse.emf.spi.cdo.InternalCDOView; |
| import org.eclipse.emf.spi.cdo.InternalCDOView.ViewAndState; |
| |
| import java.lang.reflect.Field; |
| import java.text.MessageFormat; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.concurrent.locks.Lock; |
| |
| /** |
| * @author Eike Stepper |
| */ |
| public final class CDOStateMachine extends FiniteStateMachine<CDOState, CDOEvent, InternalCDOObject> |
| { |
| // @Singleton |
| public static final CDOStateMachine INSTANCE = new CDOStateMachine(); |
| |
| static final ThreadLocal<Boolean> SWITCHING_TARGET = new InheritableThreadLocal<Boolean>(); |
| |
| private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG_STATEMACHINE, CDOStateMachine.class); |
| |
| private static final Field NATIVE_VIEW_AND_STATE_FIELD = ReflectUtil.getAccessibleField(CDOObjectImpl.class, "viewAndState"); |
| |
| private static final Field LEGACY_VIEW_AND_STATE_FIELD = ReflectUtil.getAccessibleField(CDOLegacyWrapper.class, "viewAndState"); |
| |
| private InternalCDOObject lastTracedObject; |
| |
| private CDOState lastTracedState; |
| |
| private CDOEvent lastTracedEvent; |
| |
| @SuppressWarnings("unchecked") |
| private CDOStateMachine() |
| { |
| super(CDOState.class, CDOEvent.class); |
| |
| init(CDOState.TRANSIENT, CDOEvent.PREPARE, new PrepareTransition()); |
| init(CDOState.TRANSIENT, CDOEvent.ATTACH, FAIL); |
| init(CDOState.TRANSIENT, CDOEvent.DETACH, IGNORE); |
| init(CDOState.TRANSIENT, CDOEvent.REATTACH, new ReattachTransition()); |
| init(CDOState.TRANSIENT, CDOEvent.READ, IGNORE); |
| init(CDOState.TRANSIENT, CDOEvent.WRITE, IGNORE); |
| init(CDOState.TRANSIENT, CDOEvent.INVALIDATE, IGNORE); |
| init(CDOState.TRANSIENT, CDOEvent.DETACH_REMOTE, IGNORE); |
| init(CDOState.TRANSIENT, CDOEvent.COMMIT, FAIL); |
| init(CDOState.TRANSIENT, CDOEvent.ROLLBACK, FAIL); |
| |
| init(CDOState.PREPARED, CDOEvent.PREPARE, FAIL); |
| init(CDOState.PREPARED, CDOEvent.ATTACH, new AttachTransition()); |
| init(CDOState.PREPARED, CDOEvent.DETACH, FAIL); |
| init(CDOState.PREPARED, CDOEvent.REATTACH, FAIL); |
| init(CDOState.PREPARED, CDOEvent.READ, IGNORE); |
| init(CDOState.PREPARED, CDOEvent.WRITE, FAIL); |
| init(CDOState.PREPARED, CDOEvent.INVALIDATE, FAIL); |
| init(CDOState.PREPARED, CDOEvent.DETACH_REMOTE, FAIL); |
| init(CDOState.PREPARED, CDOEvent.COMMIT, FAIL); |
| init(CDOState.PREPARED, CDOEvent.ROLLBACK, FAIL); |
| |
| init(CDOState.NEW, CDOEvent.PREPARE, FAIL); |
| init(CDOState.NEW, CDOEvent.ATTACH, FAIL); |
| init(CDOState.NEW, CDOEvent.DETACH, new DetachTransition()); |
| init(CDOState.NEW, CDOEvent.REATTACH, FAIL); |
| init(CDOState.NEW, CDOEvent.READ, IGNORE); |
| init(CDOState.NEW, CDOEvent.WRITE, new WriteNewTransition()); |
| init(CDOState.NEW, CDOEvent.INVALIDATE, DetachRemoteTransition.INSTANCE); |
| init(CDOState.NEW, CDOEvent.DETACH_REMOTE, FAIL); |
| init(CDOState.NEW, CDOEvent.COMMIT, new CommitTransition(false)); |
| init(CDOState.NEW, CDOEvent.ROLLBACK, new RollbackTransition()); |
| |
| init(CDOState.CLEAN, CDOEvent.PREPARE, FAIL); |
| init(CDOState.CLEAN, CDOEvent.ATTACH, FAIL); |
| init(CDOState.CLEAN, CDOEvent.DETACH, new DetachTransition()); |
| init(CDOState.CLEAN, CDOEvent.REATTACH, FAIL); |
| init(CDOState.CLEAN, CDOEvent.READ, IGNORE); |
| init(CDOState.CLEAN, CDOEvent.WRITE, new WriteTransition(false)); |
| init(CDOState.CLEAN, CDOEvent.INVALIDATE, new InvalidateTransition()); |
| init(CDOState.CLEAN, CDOEvent.DETACH_REMOTE, DetachRemoteTransition.INSTANCE); |
| init(CDOState.CLEAN, CDOEvent.COMMIT, FAIL); |
| init(CDOState.CLEAN, CDOEvent.ROLLBACK, FAIL); |
| |
| init(CDOState.DIRTY, CDOEvent.PREPARE, FAIL); |
| init(CDOState.DIRTY, CDOEvent.ATTACH, FAIL); |
| init(CDOState.DIRTY, CDOEvent.DETACH, new DetachTransition()); |
| init(CDOState.DIRTY, CDOEvent.REATTACH, FAIL); |
| init(CDOState.DIRTY, CDOEvent.READ, IGNORE); |
| init(CDOState.DIRTY, CDOEvent.WRITE, new RewriteTransition()); |
| init(CDOState.DIRTY, CDOEvent.INVALIDATE, new ConflictTransition()); |
| init(CDOState.DIRTY, CDOEvent.DETACH_REMOTE, new InvalidConflictTransition()); |
| init(CDOState.DIRTY, CDOEvent.COMMIT, new CommitTransition(true)); |
| init(CDOState.DIRTY, CDOEvent.ROLLBACK, new RollbackTransition()); |
| |
| init(CDOState.PROXY, CDOEvent.PREPARE, FAIL); |
| init(CDOState.PROXY, CDOEvent.ATTACH, FAIL); |
| init(CDOState.PROXY, CDOEvent.DETACH, new DetachTransition()); |
| init(CDOState.PROXY, CDOEvent.REATTACH, FAIL); |
| init(CDOState.PROXY, CDOEvent.READ, new LoadTransition()); |
| init(CDOState.PROXY, CDOEvent.WRITE, new WriteTransition(true)); |
| init(CDOState.PROXY, CDOEvent.INVALIDATE, IGNORE); |
| init(CDOState.PROXY, CDOEvent.DETACH_REMOTE, DetachRemoteTransition.INSTANCE); |
| init(CDOState.PROXY, CDOEvent.COMMIT, FAIL); |
| init(CDOState.PROXY, CDOEvent.ROLLBACK, FAIL); |
| |
| init(CDOState.CONFLICT, CDOEvent.PREPARE, FAIL); |
| init(CDOState.CONFLICT, CDOEvent.ATTACH, IGNORE); |
| init(CDOState.CONFLICT, CDOEvent.DETACH, new DetachTransition()); |
| init(CDOState.CONFLICT, CDOEvent.REATTACH, FAIL); |
| init(CDOState.CONFLICT, CDOEvent.READ, IGNORE); |
| init(CDOState.CONFLICT, CDOEvent.WRITE, new RewriteTransition()); |
| init(CDOState.CONFLICT, CDOEvent.INVALIDATE, IGNORE); |
| init(CDOState.CONFLICT, CDOEvent.DETACH_REMOTE, IGNORE); |
| init(CDOState.CONFLICT, CDOEvent.COMMIT, IGNORE); |
| init(CDOState.CONFLICT, CDOEvent.ROLLBACK, new RollbackTransition()); |
| |
| init(CDOState.INVALID, CDOEvent.PREPARE, InvalidTransition.INSTANCE); |
| init(CDOState.INVALID, CDOEvent.ATTACH, InvalidTransition.INSTANCE); |
| init(CDOState.INVALID, CDOEvent.DETACH, InvalidTransition.INSTANCE); |
| init(CDOState.INVALID, CDOEvent.REATTACH, FAIL); |
| init(CDOState.INVALID, CDOEvent.READ, InvalidTransition.INSTANCE); |
| init(CDOState.INVALID, CDOEvent.WRITE, InvalidTransition.INSTANCE); |
| init(CDOState.INVALID, CDOEvent.INVALIDATE, IGNORE); // TODO Handle changeViewTarget!!! |
| init(CDOState.INVALID, CDOEvent.DETACH_REMOTE, IGNORE); |
| init(CDOState.INVALID, CDOEvent.COMMIT, InvalidTransition.INSTANCE); |
| init(CDOState.INVALID, CDOEvent.ROLLBACK, InvalidTransition.INSTANCE); |
| |
| init(CDOState.INVALID_CONFLICT, CDOEvent.PREPARE, InvalidTransition.INSTANCE); |
| init(CDOState.INVALID_CONFLICT, CDOEvent.ATTACH, InvalidTransition.INSTANCE); |
| init(CDOState.INVALID_CONFLICT, CDOEvent.DETACH, InvalidTransition.INSTANCE); |
| init(CDOState.INVALID_CONFLICT, CDOEvent.REATTACH, FAIL); |
| init(CDOState.INVALID_CONFLICT, CDOEvent.READ, IGNORE); |
| init(CDOState.INVALID_CONFLICT, CDOEvent.WRITE, IGNORE); |
| init(CDOState.INVALID_CONFLICT, CDOEvent.INVALIDATE, IGNORE); |
| init(CDOState.INVALID_CONFLICT, CDOEvent.DETACH_REMOTE, IGNORE); |
| init(CDOState.INVALID_CONFLICT, CDOEvent.COMMIT, InvalidTransition.INSTANCE); |
| init(CDOState.INVALID_CONFLICT, CDOEvent.ROLLBACK, DetachRemoteTransition.INSTANCE); |
| } |
| |
| /** |
| * The object is already attached in EMF world. It contains all the information needed to know where it will be connected. |
| */ |
| public void attach(InternalCDOObject object, InternalCDOTransaction transaction) |
| { |
| synchronized (transaction.getViewMonitor()) |
| { |
| transaction.lockView(); |
| |
| try |
| { |
| object.cdoInternalPreAttach(); |
| |
| List<InternalCDOObject> contents = new ArrayList<InternalCDOObject>(); |
| prepare(object, Pair.create(transaction, contents)); |
| |
| attachOrReattach(object, transaction); |
| for (InternalCDOObject content : contents) |
| { |
| attachOrReattach(content, transaction); |
| } |
| } |
| finally |
| { |
| transaction.unlockView(); |
| } |
| } |
| } |
| |
| private void attachOrReattach(InternalCDOObject object, InternalCDOTransaction transaction) |
| { |
| // Bug 283985 (Re-attachment): |
| // If the object going through a prepareTransition is present in cleanRevisions, |
| // then it was detached earlier, and so we can infer that it is being re-attached |
| if (transaction.getCleanRevisions().containsKey(object)) |
| { |
| reattachObject(object, transaction); |
| } |
| else |
| { |
| attachObject(object); |
| } |
| } |
| |
| /** |
| * Phase 1: TRANSIENT --> PREPARED |
| */ |
| private void prepare(InternalCDOObject object, Pair<InternalCDOTransaction, List<InternalCDOObject>> transactionAndContents) |
| { |
| if (TRACER.isEnabled()) |
| { |
| TRACER.format("PREPARE: {0} --> {1}", object, transactionAndContents.getElement1()); //$NON-NLS-1$ |
| } |
| |
| process(object, CDOEvent.PREPARE, transactionAndContents); |
| } |
| |
| /** |
| * Phase 2: PREPARED --> NEW |
| */ |
| private void attachObject(InternalCDOObject object) |
| { |
| if (TRACER.isEnabled()) |
| { |
| TRACER.format("ATTACH: {0}", object); //$NON-NLS-1$ |
| } |
| |
| process(object, CDOEvent.ATTACH, null); |
| } |
| |
| private void reattachObject(InternalCDOObject object, InternalCDOTransaction transaction) |
| { |
| if (TRACER.isEnabled()) |
| { |
| TRACER.format("REATTACH: {0}", object); |
| } |
| |
| process(object, CDOEvent.REATTACH, transaction); |
| } |
| |
| public void detach(InternalCDOObject object) |
| { |
| synchronized (getMonitor(object)) |
| { |
| Lock lock = getLock(object); |
| if (lock != null) |
| { |
| lock.lock(); |
| } |
| |
| try |
| { |
| if (TRACER.isEnabled()) |
| { |
| trace(object, CDOEvent.DETACH); |
| } |
| |
| List<InternalCDOObject> objectsToDetach = new ArrayList<InternalCDOObject>(); |
| InternalCDOTransaction transaction = (InternalCDOTransaction)object.cdoView(); |
| |
| // Accumulate objects that needs to be detached |
| // If we have an error, we will keep the graph exactly like it was before. |
| process(object, CDOEvent.DETACH, objectsToDetach); |
| |
| // postDetach() requires the object to be TRANSIENT, but listeners must not be notified at this point! |
| for (InternalCDOObject content : objectsToDetach) |
| { |
| CDOState oldState = setStateQuietely(content, CDOState.TRANSIENT); |
| content.cdoInternalPostDetach(false); |
| setStateQuietely(content, oldState); |
| } |
| |
| // detachObject() needs to know the state before we change the object to TRANSIENT |
| for (InternalCDOObject content : objectsToDetach) |
| { |
| transaction.detachObject(content); |
| content.cdoInternalSetState(CDOState.TRANSIENT); |
| |
| content.cdoInternalSetView(null); |
| content.cdoInternalSetID(null); |
| } |
| } |
| finally |
| { |
| if (lock != null) |
| { |
| lock.unlock(); |
| } |
| } |
| } |
| } |
| |
| public InternalCDORevision read(InternalCDOObject object) |
| { |
| synchronized (getMonitor(object)) |
| { |
| Lock lock = getLock(object); |
| if (lock != null) |
| { |
| lock.lock(); |
| } |
| |
| try |
| { |
| if (TRACER.isEnabled()) |
| { |
| trace(object, CDOEvent.READ); |
| } |
| |
| process(object, CDOEvent.READ, null); |
| return object.cdoRevision(); |
| } |
| finally |
| { |
| if (lock != null) |
| { |
| lock.unlock(); |
| } |
| } |
| } |
| } |
| |
| public InternalCDORevision readNoLoad(InternalCDOObject object) |
| { |
| synchronized (getMonitor(object)) |
| { |
| Lock lock = getLock(object); |
| if (lock != null) |
| { |
| lock.lock(); |
| } |
| |
| try |
| { |
| switch (object.cdoState()) |
| { |
| case TRANSIENT: |
| case PREPARED: |
| case NEW: |
| case CONFLICT: |
| case INVALID_CONFLICT: |
| case INVALID: |
| case PROXY: |
| return null; |
| } |
| |
| return object.cdoRevision(); |
| } |
| finally |
| { |
| if (lock != null) |
| { |
| lock.unlock(); |
| } |
| } |
| } |
| } |
| |
| public Object write(InternalCDOObject object, CDOFeatureDelta featureDelta) |
| { |
| synchronized (getMonitor(object)) |
| { |
| Lock lock = getLock(object); |
| if (lock != null) |
| { |
| lock.lock(); |
| } |
| |
| try |
| { |
| return writeUnsynced(object, featureDelta); |
| } |
| finally |
| { |
| if (lock != null) |
| { |
| lock.unlock(); |
| } |
| } |
| } |
| } |
| |
| public Object writeUnsynced(InternalCDOObject object, CDOFeatureDelta featureDelta) |
| { |
| if (TRACER.isEnabled()) |
| { |
| trace(object, CDOEvent.WRITE); |
| } |
| |
| // TODO: Make FeatureDeltaAndResult constant |
| FeatureDeltaAndResult featureDeltaAndResult = new FeatureDeltaAndResult(featureDelta); |
| |
| process(object, CDOEvent.WRITE, featureDeltaAndResult); |
| return featureDeltaAndResult.getResult(); |
| } |
| |
| public void reload(InternalCDOObject... objects) |
| { |
| if (objects == null || objects.length == 0) |
| { |
| return; |
| } |
| |
| synchronized (getMonitor(objects[0])) |
| { |
| Lock lock = getLock(objects[0]); |
| if (lock != null) |
| { |
| lock.lock(); |
| } |
| |
| try |
| { |
| for (InternalCDOObject object : objects) |
| { |
| CDOState state = object.cdoState(); |
| if (state == CDOState.CLEAN || state == CDOState.PROXY) |
| { |
| changeState(object, CDOState.PROXY); |
| object.cdoInternalSetRevision(null); |
| read(object); |
| } |
| } |
| } |
| finally |
| { |
| if (lock != null) |
| { |
| lock.unlock(); |
| } |
| } |
| } |
| } |
| |
| public void invalidate(InternalCDOObject object, CDORevisionKey key) |
| { |
| synchronized (getMonitor(object)) |
| { |
| Lock lock = getLock(object); |
| if (lock != null) |
| { |
| lock.lock(); |
| } |
| |
| try |
| { |
| if (TRACER.isEnabled()) |
| { |
| trace(object, CDOEvent.INVALIDATE); |
| } |
| |
| process(object, CDOEvent.INVALIDATE, key); |
| } |
| finally |
| { |
| if (lock != null) |
| { |
| lock.unlock(); |
| } |
| } |
| } |
| } |
| |
| public void detachRemote(InternalCDOObject object) |
| { |
| synchronized (getMonitor(object)) |
| { |
| Lock lock = getLock(object); |
| if (lock != null) |
| { |
| lock.lock(); |
| } |
| |
| try |
| { |
| if (TRACER.isEnabled()) |
| { |
| trace(object, CDOEvent.DETACH_REMOTE); |
| } |
| |
| process(object, CDOEvent.DETACH_REMOTE, null); |
| } |
| finally |
| { |
| if (lock != null) |
| { |
| lock.unlock(); |
| } |
| } |
| } |
| } |
| |
| public void commit(Map<CDOID, CDOObject> objects, CommitTransactionResult result) |
| { |
| for (CDOObject object : objects.values()) |
| { |
| commitObject((InternalCDOObject)object, result); |
| } |
| |
| for (CDOObject object : objects.values()) |
| { |
| changeState((InternalCDOObject)object, CDOState.CLEAN); |
| } |
| } |
| |
| private void commitObject(InternalCDOObject object, CommitTransactionResult result) |
| { |
| synchronized (getMonitor(object)) |
| { |
| Lock lock = getLock(object); |
| if (lock != null) |
| { |
| lock.lock(); |
| } |
| |
| try |
| { |
| if (TRACER.isEnabled()) |
| { |
| trace(object, CDOEvent.COMMIT); |
| } |
| |
| process(object, CDOEvent.COMMIT, result); |
| } |
| finally |
| { |
| if (lock != null) |
| { |
| lock.unlock(); |
| } |
| } |
| } |
| } |
| |
| public void rollback(InternalCDOObject object, InternalCDOTransaction transaction) |
| { |
| synchronized (getMonitor(object)) |
| { |
| Lock lock = getLock(object); |
| if (lock != null) |
| { |
| lock.lock(); |
| } |
| |
| try |
| { |
| if (TRACER.isEnabled()) |
| { |
| trace(object, CDOEvent.ROLLBACK); |
| } |
| |
| process(object, CDOEvent.ROLLBACK, transaction); |
| } |
| finally |
| { |
| if (lock != null) |
| { |
| lock.unlock(); |
| } |
| } |
| } |
| } |
| |
| @Override |
| protected CDOState getState(InternalCDOObject object) |
| { |
| return object.cdoState(); |
| } |
| |
| @Override |
| protected void setState(InternalCDOObject object, CDOState state) |
| { |
| object.cdoInternalSetState(state); |
| } |
| |
| private CDOState setStateQuietely(InternalCDOObject object, CDOState state) |
| { |
| Field viewAndStateField; |
| if (object instanceof CDOObjectImpl) |
| { |
| viewAndStateField = NATIVE_VIEW_AND_STATE_FIELD; |
| } |
| else if (object instanceof CDOLegacyWrapper) |
| { |
| viewAndStateField = LEGACY_VIEW_AND_STATE_FIELD; |
| } |
| else |
| { |
| return object.cdoInternalSetState(state); |
| } |
| |
| try |
| { |
| ViewAndState viewAndState = (ViewAndState)viewAndStateField.get(object); |
| CDOState oldState = viewAndState.state; |
| ReflectUtil.setValue(viewAndStateField, object, viewAndState.getViewAndState(state)); |
| return oldState; |
| } |
| catch (Exception ex) |
| { |
| return object.cdoInternalSetState(state); |
| } |
| } |
| |
| private Lock getLock(InternalCDOObject object) |
| { |
| InternalCDOView view = object.cdoView(); |
| if (view != null) |
| { |
| return view.getViewLock(); |
| } |
| |
| // In TRANSIENT and PREPARED the object is not yet attached to a view |
| return null; |
| } |
| |
| private Object getMonitor(InternalCDOObject object) |
| { |
| InternalCDOView view = object.cdoView(); |
| if (view != null) |
| { |
| return view.getViewMonitor(); |
| } |
| |
| // In TRANSIENT and PREPARED the object is not yet attached to a view |
| return object; |
| } |
| |
| /** |
| * Removes clutter from the trace log |
| */ |
| private void trace(InternalCDOObject object, CDOEvent event) |
| { |
| CDOState state = object.cdoState(); |
| if (lastTracedObject != object || lastTracedState != state || lastTracedEvent != event) |
| { |
| TRACER.format("{0}: {1}", event, object.getClass().getName()); //$NON-NLS-1$ |
| lastTracedObject = object; |
| lastTracedState = state; |
| lastTracedEvent = event; |
| } |
| } |
| |
| @SuppressWarnings("unused") |
| private void testAttach(InternalCDOObject object) |
| { |
| process(object, CDOEvent.ATTACH, null); |
| } |
| |
| public void internalReattach(InternalCDOObject object, InternalCDOTransaction transaction) |
| { |
| InternalCDORevisionManager revisionManager = transaction.getSession().getRevisionManager(); |
| InternalCDORevision cleanRevision = transaction.getCleanRevisions().get(object).copy(); |
| CDOID id = cleanRevision.getID(); |
| |
| // Bug 373096: Determine clean revision of the CURRENT/LAST savepoint |
| InternalCDOSavepoint savepoint = transaction.getFirstSavepoint(); |
| while (savepoint.getNextSavepoint() != null) |
| { |
| CDORevisionDelta delta = savepoint.getRevisionDeltas2().get(id); |
| if (delta != null) |
| { |
| delta.applyTo(cleanRevision); |
| } |
| |
| savepoint = savepoint.getNextSavepoint(); |
| } |
| |
| object.cdoInternalSetView(transaction); |
| |
| // Construct a new revision |
| CDORevisionFactory factory = revisionManager.getFactory(); |
| InternalCDORevision revision = (InternalCDORevision)factory.createRevision(object.eClass()); |
| revision.setID(id); |
| revision.setBranchPoint(cleanRevision.getBranch().getHead()); |
| revision.setVersion(cleanRevision.getVersion()); |
| |
| // Populate the revision based on the values in the CDOObject |
| object.cdoInternalSetRevision(revision); |
| object.cdoInternalPostAttach(); |
| |
| // Compute a revision delta and register it with the tx |
| InternalCDORevisionDelta revisionDelta = revision.compare(cleanRevision); |
| if (revisionDelta.isEmpty()) |
| { |
| changeState(object, CDOState.CLEAN); |
| } |
| else |
| { |
| revisionDelta.setTarget(null); |
| transaction.registerRevisionDelta(revisionDelta); |
| transaction.registerDirty(object, (CDOFeatureDelta)null); |
| changeState(object, CDOState.DIRTY); |
| } |
| |
| // Add the object to the set of reattached objects |
| InternalCDOSavepoint lastSavepoint = transaction.getLastSavepoint(); |
| lastSavepoint.getReattachedObjects().put(id, object); |
| } |
| |
| public void dispatchLoadNotification(InternalCDOObject object) |
| { |
| InternalCDOView view = object.cdoView(); |
| if (view.options().isLoadNotificationEnabled()) |
| { |
| try |
| { |
| InternalCDORevision revision = object.cdoRevision(); |
| CDONotificationBuilder builder = new CDONotificationBuilder(view); |
| |
| NotificationChain notification = builder.buildNotification(object, revision); |
| if (notification != null) |
| { |
| notification.dispatch(); |
| } |
| } |
| catch (PartialCollectionLoadingNotSupportedException ex) |
| { |
| if (TRACER.isEnabled()) |
| { |
| TRACER.trace(ex); |
| } |
| } |
| } |
| } |
| |
| private void internalLoad(InternalCDOObject object, boolean forWrite) |
| { |
| object.cdoInternalPreLoad(); |
| |
| InternalCDOView view = object.cdoView(); |
| InternalCDORevision revision = view.getRevision(object.cdoID(), true); |
| if (revision == null) |
| { |
| INSTANCE.detachRemote(object); |
| CDOInvalidationPolicy policy = view.options().getInvalidationPolicy(); |
| policy.handleInvalidObject(object); |
| } |
| |
| if (forWrite && !revision.isWritable()) |
| { |
| throw new NoPermissionException(revision); |
| } |
| |
| object.cdoInternalSetRevision(revision); |
| changeState(object, CDOState.CLEAN); |
| object.cdoInternalPostLoad(); |
| dispatchLoadNotification(object); |
| } |
| |
| /** |
| * @author Eike Stepper |
| */ |
| public static final class FeatureDeltaAndResult |
| { |
| private final CDOFeatureDelta featureDelta; |
| |
| private Object result; |
| |
| public FeatureDeltaAndResult(CDOFeatureDelta featureDelta) |
| { |
| this.featureDelta = featureDelta; |
| } |
| |
| public CDOFeatureDelta getFeatureDelta() |
| { |
| return featureDelta; |
| } |
| |
| public Object getResult() |
| { |
| return result; |
| } |
| |
| public void setResult(Object result) |
| { |
| this.result = result; |
| } |
| } |
| |
| /** |
| * Prepares a tree of transient objects to be subsequently {@link AttachTransition attached} to a CDOView. |
| * <p> |
| * Execution is recursive and includes: |
| * <ol> |
| * <li>Assignment of a new {@link CDOIDTemp} |
| * <li>Assignment of a new {@link CDORevision} |
| * <li>Bidirectional association with the {@link CDOView} |
| * <li>Registration with the {@link CDOTransaction} |
| * <li>Changing state to {@link CDOState#PREPARED PREPARED} |
| * </ol> |
| * |
| * @see AttachTransition |
| * @author Eike Stepper |
| */ |
| private final class PrepareTransition implements ITransition<CDOState, CDOEvent, InternalCDOObject, Pair<InternalCDOTransaction, List<InternalCDOObject>>> |
| { |
| public void execute(InternalCDOObject object, CDOState state, CDOEvent event, Pair<InternalCDOTransaction, List<InternalCDOObject>> transactionAndContents) |
| { |
| InternalCDOTransaction transaction = transactionAndContents.getElement1(); |
| List<InternalCDOObject> contents = transactionAndContents.getElement2(); |
| |
| // If the object going through a prepareTransition is present in cleanRevisions, |
| // then it was detached earlier, and so we can infer that it is being re-attached |
| boolean reattaching = transaction.getCleanRevisions().containsKey(object); |
| |
| if (!reattaching) |
| { |
| // Prepare object |
| CDOID id = transaction.createIDForNewObject(object.cdoInternalInstance()); |
| object.cdoInternalSetView(transaction); |
| changeState(object, CDOState.PREPARED); |
| |
| // Create new revision |
| EClass eClass = object.eClass(); |
| InternalCDOSession session = transaction.getSession(); |
| checkPackageRegistrationProblems(session, eClass); |
| |
| CDORevisionFactory factory = session.getRevisionManager().getFactory(); |
| InternalCDORevision revision = (InternalCDORevision)factory.createRevision(eClass); |
| revision.setID(id); |
| revision.setBranchPoint(transaction.getBranch().getHead()); |
| |
| object.cdoInternalSetRevision(revision); |
| |
| // Register object |
| transaction.registerObject(object); |
| } |
| |
| transaction.registerAttached(object, !reattaching); |
| |
| // Prepare content tree |
| for (Iterator<InternalEObject> it = getPersistentContents(object); it.hasNext();) |
| { |
| InternalEObject content = it.next(); |
| Resource.Internal directResource = content.eDirectResource(); |
| |
| boolean objectIsResource = directResource == object; |
| if (objectIsResource || directResource == null) |
| { |
| InternalCDOObject adapted = FSMUtil.adapt(content, transaction); |
| contents.add(adapted); |
| INSTANCE.process(adapted, CDOEvent.PREPARE, transactionAndContents); |
| } |
| } |
| } |
| |
| private Iterator<InternalEObject> getPersistentContents(InternalCDOObject object) |
| { |
| EStructuralFeature[] features = object.cdoClassInfo().getAllPersistentContainments(); |
| return new EContentsEList.ResolvingFeatureIteratorImpl<InternalEObject>(object, features); |
| } |
| |
| private void checkPackageRegistrationProblems(InternalCDOSession session, EClass eClass) |
| { |
| if (session.options().isGeneratedPackageEmulationEnabled()) |
| { |
| // Check that there are no multiple EPackages with the same URI in system. Bug 335004 |
| String packageURI = eClass.getEPackage().getNsURI(); |
| Object packageObject = session.getPackageRegistry().get(packageURI); |
| if (packageObject instanceof InternalCDOPackageInfo) |
| { |
| packageObject = ((InternalCDOPackageInfo)packageObject).getEPackage(false); |
| } |
| |
| if (packageObject instanceof EPackage && packageObject != eClass.getEPackage()) |
| { |
| throw new IllegalStateException( |
| MessageFormat.format("Global EPackage {0} for EClass {1} is different from EPackage found in CDOPackageRegistry", packageURI, eClass)); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Attaches a tree of {@link PrepareTransition prepared} objects to a CDOView. |
| * <p> |
| * Execution is recursive and includes: |
| * <ol> |
| * <li>Calling {@link InternalCDOObject#cdoInternalPostAttach()},<br> |
| * which includes for {@link CDOObjectImpl}: |
| * <ol> |
| * <li>Population of the CDORevision with the current values in |
| * {@link EStoreEObjectImpl#eSetting(org.eclipse.emf.ecore.EStructuralFeature) eSettings} |
| * <li>Unsetting {@link EStoreEObjectImpl#eSetting(org.eclipse.emf.ecore.EStructuralFeature) eSettings} |
| * </ol> |
| * <li>Changing state to {@link CDOState#NEW NEW} |
| * </ol> |
| * |
| * @see PrepareTransition |
| * @author Eike Stepper |
| */ |
| private final class AttachTransition implements ITransition<CDOState, CDOEvent, InternalCDOObject, Object> |
| { |
| public void execute(InternalCDOObject object, CDOState state, CDOEvent event, Object NULL) |
| { |
| // Transfer the EObject values into a CDORevision. |
| object.cdoInternalPostAttach(); |
| |
| // Remember a copy of the new revision that can be used in case of a later rollback to reset the object. |
| Map<CDOID, CDORevision> attachedRevisions = ((InternalCDOTransaction)object.cdoView()).options().getAttachedRevisionsMap(); |
| if (attachedRevisions != null) |
| { |
| InternalCDORevision revision = object.cdoRevision().copy(); |
| |
| // This revision copy contains the container reference AFTER the attachment. |
| // At rollback time it may have to be unset if this object is the root of an attached tree! |
| attachedRevisions.put(revision.getID(), revision); |
| } |
| |
| changeState(object, CDOState.NEW); |
| } |
| } |
| |
| /** |
| * Bug 283985 (Re-attachment) |
| * |
| * @author Caspar De Groot |
| */ |
| private final class ReattachTransition implements ITransition<CDOState, CDOEvent, InternalCDOObject, InternalCDOTransaction> |
| { |
| public void execute(InternalCDOObject object, CDOState state, CDOEvent event, InternalCDOTransaction transaction) |
| { |
| internalReattach(object, transaction); |
| |
| // Bug 385268 |
| CDOID reattachedObject = object.cdoID(); |
| processRevisionDeltas(reattachedObject, transaction); |
| } |
| |
| private void processRevisionDeltas(CDOID reattachedObject, InternalCDOTransaction transaction) |
| { |
| InternalCDOSavepoint lastSavepoint = transaction.getLastSavepoint(); |
| Map<CDOID, CDORevisionDelta> revisionDeltas = lastSavepoint.getRevisionDeltas2(); |
| for (Iterator<Entry<CDOID, CDORevisionDelta>> it = revisionDeltas.entrySet().iterator(); it.hasNext();) |
| { |
| Entry<CDOID, CDORevisionDelta> entry = it.next(); |
| CDORevisionDelta revisionDelta = entry.getValue(); |
| |
| Map<EStructuralFeature, CDOFeatureDelta> map = ((InternalCDORevisionDelta)revisionDelta).getFeatureDeltaMap(); |
| processFeatureDeltas(reattachedObject, map); |
| |
| if (revisionDelta.isEmpty()) |
| { |
| it.remove(); |
| |
| CDOID id = revisionDelta.getID(); |
| InternalCDOObject cleanObject = (InternalCDOObject)lastSavepoint.getDirtyObjects().remove(id); |
| if (cleanObject != null) |
| { |
| cleanObject.cdoInternalSetState(CDOState.CLEAN); |
| } |
| } |
| } |
| |
| if (revisionDeltas.isEmpty()) |
| { |
| transaction.setDirty(false); |
| } |
| } |
| |
| private void processFeatureDeltas(CDOID reattachedObject, Map<EStructuralFeature, CDOFeatureDelta> map) |
| { |
| for (Iterator<Entry<EStructuralFeature, CDOFeatureDelta>> it = map.entrySet().iterator(); it.hasNext();) |
| { |
| Entry<EStructuralFeature, CDOFeatureDelta> entry = it.next(); |
| CDOFeatureDelta featureDelta = entry.getValue(); |
| processFeatureDelta(reattachedObject, it, featureDelta); |
| } |
| } |
| |
| private void processFeatureDelta(CDOID reattachedObject, Iterator<?> it, CDOFeatureDelta featureDelta) |
| { |
| switch (featureDelta.getType()) |
| { |
| case SET: |
| CDOSetFeatureDelta setFeatureDelta = (CDOSetFeatureDelta)featureDelta; |
| Object oldValue = setFeatureDelta.getOldValue(); |
| if (oldValue instanceof EObject) |
| { |
| oldValue = CDOUtil.getCDOObject((EObject)oldValue).cdoID(); |
| } |
| |
| Object newValue = setFeatureDelta.getValue(); |
| if (newValue instanceof EObject) |
| { |
| newValue = CDOUtil.getCDOObject((EObject)newValue).cdoID(); |
| } |
| |
| if (reattachedObject == oldValue && reattachedObject == newValue) |
| { |
| it.remove(); |
| } |
| |
| break; |
| |
| case LIST: |
| CDOListFeatureDelta listFeatureDelta = (CDOListFeatureDelta)featureDelta; |
| List<CDOFeatureDelta> listChanges = listFeatureDelta.getListChanges(); |
| for (Iterator<CDOFeatureDelta> listIt = listChanges.iterator(); listIt.hasNext();) |
| { |
| CDOFeatureDelta singleFeatureDelta = listIt.next(); |
| processFeatureDelta(reattachedObject, listIt, singleFeatureDelta); |
| } |
| |
| if (listChanges.isEmpty()) |
| { |
| it.remove(); |
| } |
| |
| break; |
| } |
| } |
| } |
| |
| /** |
| * @author Eike Stepper |
| */ |
| private static final class DetachTransition implements ITransition<CDOState, CDOEvent, InternalCDOObject, List<InternalCDOObject>> |
| { |
| public void execute(InternalCDOObject object, CDOState state, CDOEvent event, List<InternalCDOObject> objectsToDetach) |
| { |
| InternalCDOTransaction transaction = (InternalCDOTransaction)object.cdoView(); |
| objectsToDetach.add(object); |
| boolean isResource = object instanceof Resource; |
| |
| // Prepare content tree |
| for (Iterator<EObject> it = object.eContents().iterator(); it.hasNext();) |
| { |
| InternalEObject eObject = (InternalEObject)it.next(); |
| boolean isDirectlyConnected = isResource && eObject.eDirectResource() == object; |
| if (isDirectlyConnected || eObject.eDirectResource() == null) |
| { |
| InternalCDOObject content = FSMUtil.adapt(eObject, transaction); |
| if (content != null) |
| { |
| INSTANCE.process(content, CDOEvent.DETACH, objectsToDetach); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * @author Eike Stepper |
| */ |
| private final class CommitTransition implements ITransition<CDOState, CDOEvent, InternalCDOObject, CommitTransactionResult> |
| { |
| public CommitTransition(boolean useDeltas) |
| { |
| } |
| |
| public void execute(InternalCDOObject object, CDOState state, CDOEvent event, CommitTransactionResult data) |
| { |
| InternalCDOTransaction transaction = object.cdoView().toTransaction(); |
| InternalCDORevision revision = object.cdoRevision(); |
| Map<CDOID, CDOID> idMappings = data.getIDMappings(); |
| |
| // Adjust object |
| CDOID oldID = object.cdoID(); |
| CDOID newID = idMappings.get(oldID); |
| if (newID != null) |
| { |
| revision.setID(newID); |
| transaction.remapObject(oldID); |
| } |
| |
| // Adjust revision |
| revision.adjustForCommit(transaction.getBranch(), data.getTimeStamp()); |
| revision.adjustReferences(data.getReferenceAdjuster()); |
| revision.freeze(); |
| |
| InternalCDORevisionManager revisionManager = transaction.getSession().getRevisionManager(); |
| revisionManager.addRevision(revision); |
| } |
| } |
| |
| /** |
| * @author Eike Stepper |
| */ |
| private final class RollbackTransition implements ITransition<CDOState, CDOEvent, InternalCDOObject, InternalCDOTransaction> |
| { |
| public void execute(InternalCDOObject object, CDOState state, CDOEvent event, InternalCDOTransaction transaction) |
| { |
| CDOID id = object.cdoID(); |
| if (transaction.getLastSavepoint().isNewObject(id)) |
| { |
| // Map<CDOID, CDORevision> attachedRevisions = transaction.options().getAttachedRevisionsMap(); |
| // if (attachedRevisions != null) |
| // { |
| // InternalCDORevision revision = (InternalCDORevision)attachedRevisions.get(id); |
| // if (revision != null) |
| // { |
| // CDOID containerID = transaction.provideCDOID(revision.getContainerID()); |
| // if (!CDOIDUtil.isNull(containerID) && !attachedRevisions.containsKey(containerID)) |
| // { |
| // revision.setContainerID(null); |
| // revision.setContainingFeatureID(0); |
| // } |
| // |
| // CDOID resourceID = revision.getResourceID(); |
| // if (!CDOIDUtil.isNull(resourceID) && !attachedRevisions.containsKey(resourceID)) |
| // { |
| // revision.setResourceID(null); |
| // } |
| // |
| // object.cdoInternalSetRevision(revision); |
| // |
| // if (object instanceof CDOLegacyWrapper) |
| // { |
| // CDOLegacyWrapper wrapper = (CDOLegacyWrapper)object; |
| // wrapper.cdoInternalPostLoad(); |
| // } |
| // } |
| // } |
| |
| // postDetach() requires the object to be TRANSIENT, but listeners must not be notified at this point! |
| CDOState oldState = setStateQuietely(object, CDOState.TRANSIENT); |
| object.cdoInternalPostDetach(false); |
| setStateQuietely(object, oldState); |
| |
| changeState(object, CDOState.TRANSIENT); |
| } |
| else |
| { |
| changeState(object, CDOState.PROXY); |
| object.cdoInternalPostRollback(); |
| } |
| |
| object.cdoInternalSetRevision(null); |
| } |
| } |
| |
| /** |
| * @author Eike Stepper |
| */ |
| private static abstract class AbstractWriteTransition implements ITransition<CDOState, CDOEvent, InternalCDOObject, FeatureDeltaAndResult> |
| { |
| public void execute(InternalCDOObject object, CDOState state, CDOEvent event, FeatureDeltaAndResult featureDeltaAndResult) |
| { |
| InternalCDORevision revision = object.cdoRevision(); |
| if (!revision.isWritable()) |
| { |
| throw new NoPermissionException(revision); |
| } |
| |
| InternalCDOTransaction transaction = object.cdoView().toTransaction(); |
| CDOFeatureDelta featureDelta = featureDeltaAndResult.getFeatureDelta(); |
| Object result = execute(object, transaction, featureDelta, revision); |
| featureDeltaAndResult.setResult(result); |
| } |
| |
| protected abstract Object execute(InternalCDOObject object, InternalCDOTransaction transaction, CDOFeatureDelta featureDelta, InternalCDORevision revision); |
| } |
| |
| /** |
| * @author Simon McDuff |
| */ |
| private final class WriteNewTransition extends AbstractWriteTransition |
| { |
| @Override |
| protected Object execute(InternalCDOObject object, InternalCDOTransaction transaction, CDOFeatureDelta featureDelta, InternalCDORevision revision) |
| { |
| Object result = null; |
| if (featureDelta != null) |
| { |
| result = featureDelta.applyTo(revision); |
| } |
| |
| transaction.registerFeatureDelta(object, featureDelta); |
| return result; |
| } |
| } |
| |
| /** |
| * @author Eike Stepper |
| */ |
| private final class WriteTransition extends AbstractWriteTransition |
| { |
| private boolean load; |
| |
| public WriteTransition(boolean load) |
| { |
| this.load = load; |
| } |
| |
| @Override |
| public void execute(InternalCDOObject object, CDOState state, CDOEvent event, FeatureDeltaAndResult featureDeltaAndResult) |
| { |
| if (load) |
| { |
| internalLoad(object, true); |
| } |
| |
| super.execute(object, state, event, featureDeltaAndResult); |
| } |
| |
| @Override |
| protected Object execute(InternalCDOObject object, InternalCDOTransaction transaction, CDOFeatureDelta featureDelta, InternalCDORevision cleanRevision) |
| { |
| InternalCDORevision revision = cleanRevision.copy(); |
| |
| Object result = null; |
| if (featureDelta != null) |
| { |
| result = featureDelta.applyTo(revision); |
| |
| if (!transaction.hasMultipleSavepoints()) |
| { |
| CDOUndoDetector undoDetector = transaction.options().getUndoDetector(); |
| if (undoDetector.detectUndo(transaction, cleanRevision, revision, featureDelta)) |
| { |
| return null; |
| } |
| } |
| } |
| |
| transaction.getCleanRevisions().put(object, cleanRevision); |
| object.cdoInternalSetRevision(revision); |
| |
| transaction.registerDirty(object, featureDelta, cleanRevision); |
| changeState(object, CDOState.DIRTY); |
| return result; |
| } |
| } |
| |
| /** |
| * @author Simon McDuff |
| */ |
| private final class RewriteTransition extends AbstractWriteTransition |
| { |
| @Override |
| protected Object execute(InternalCDOObject object, InternalCDOTransaction transaction, CDOFeatureDelta featureDelta, InternalCDORevision revision) |
| { |
| Map<InternalCDOObject, InternalCDORevision> cleanRevisions = transaction.getCleanRevisions(); |
| InternalCDORevision cleanRevision = cleanRevisions.get(object); |
| |
| Object result = null; |
| if (featureDelta != null) |
| { |
| result = featureDelta.applyTo(revision); |
| |
| if (!transaction.hasMultipleSavepoints()) |
| { |
| CDOUndoDetector undoDetector = transaction.options().getUndoDetector(); |
| if (undoDetector.detectUndo(transaction, cleanRevision, revision, featureDelta)) |
| { |
| CDOID id = revision.getID(); |
| |
| InternalCDOSavepoint lastSavepoint = transaction.getLastSavepoint(); |
| Map<CDOID, CDORevisionDelta> revisionDeltas = lastSavepoint.getRevisionDeltas2(); |
| InternalCDORevisionDelta revisionDelta = (InternalCDORevisionDelta)revisionDeltas.get(id); |
| if (revisionDelta != null) |
| { |
| Map<EStructuralFeature, CDOFeatureDelta> featureDeltas = revisionDelta.getFeatureDeltaMap(); |
| featureDeltas.remove(featureDelta.getFeature()); |
| |
| if (featureDeltas.isEmpty()) |
| { |
| cleanRevisions.remove(object); |
| revisionDeltas.remove(id); |
| lastSavepoint.getDirtyObjects().remove(id); |
| |
| if (lastSavepoint.getReattachedObjects().remove(id) != null) |
| { |
| lastSavepoint.getDetachedObjects().remove(id); |
| } |
| |
| object.cdoInternalSetRevision(cleanRevision); |
| changeState(object, CDOState.CLEAN); |
| } |
| } |
| |
| if (revisionDeltas.isEmpty()) |
| { |
| transaction.setDirty(false); |
| } |
| |
| CDOTransactionHandler1[] handlers = transaction.getTransactionHandlers1(); |
| for (int i = 0; i < handlers.length; i++) |
| { |
| CDOTransactionHandler1 handler = handlers[i]; |
| if (handler instanceof WithUndo) |
| { |
| WithUndo withUndo = (WithUndo)handler; |
| withUndo.undoingObject(transaction, object, featureDelta); |
| } |
| } |
| |
| return result; |
| } |
| } |
| } |
| |
| transaction.registerFeatureDelta(object, featureDelta, cleanRevision); |
| return result; |
| } |
| } |
| |
| /** |
| * @author Simon McDuff |
| */ |
| private static class DetachRemoteTransition implements ITransition<CDOState, CDOEvent, InternalCDOObject, Object> |
| { |
| static final DetachRemoteTransition INSTANCE = new DetachRemoteTransition(); |
| |
| public void execute(InternalCDOObject object, CDOState state, CDOEvent event, Object NULL) |
| { |
| CDOStateMachine.INSTANCE.changeState(object, CDOState.INVALID); |
| |
| InternalCDOView view = object.cdoView(); |
| view.deregisterObject(object); |
| object.cdoInternalPostDetach(true); |
| } |
| } |
| |
| /** |
| * @author Eike Stepper |
| */ |
| private class InvalidateTransition implements ITransition<CDOState, CDOEvent, InternalCDOObject, CDORevisionKey> |
| { |
| public void execute(InternalCDOObject object, CDOState state, CDOEvent event, CDORevisionKey key) |
| { |
| InternalCDORevision oldRevision = object.cdoRevision(); |
| InternalCDOView view = object.cdoView(); |
| InternalCDOSession session = view.getSession(); |
| InternalCDORevisionCache cache = session.getRevisionManager().getCache(); |
| |
| if (SWITCHING_TARGET.get() == Boolean.TRUE) |
| { |
| CDORevisionDelta delta = (CDORevisionDelta)key; |
| CDORevisable target = delta.getTarget(); |
| InternalCDORevision newRevision = (InternalCDORevision)cache.getRevisionByVersion(delta.getID(), target); |
| if (newRevision == null) |
| { |
| newRevision = oldRevision.copy(); |
| session.resolveAllElementProxies(newRevision); |
| delta.applyTo(newRevision); |
| newRevision.setBranchPoint(target); |
| newRevision.setVersion(target.getVersion()); |
| newRevision.setRevised(target.getRevised()); |
| cache.addRevision(newRevision); |
| } |
| |
| object.cdoInternalSetRevision(newRevision); |
| changeState(object, CDOState.CLEAN); |
| object.cdoInternalPostLoad(); |
| return; |
| } |
| |
| if (key == null || key.getVersion() >= oldRevision.getVersion()) |
| { |
| InternalCDORevision newRevision = null; |
| |
| CDOBranch viewBranch = view.getBranch(); |
| CDOBranchVersion newBranchVersion = getNewBranchVersion(key, viewBranch); |
| if (newBranchVersion != null) |
| { |
| newRevision = (InternalCDORevision)cache.getRevisionByVersion(key.getID(), newBranchVersion); |
| } |
| |
| if (newRevision != null) |
| { |
| object.cdoInternalSetRevision(newRevision); |
| changeState(object, CDOState.CLEAN); |
| object.cdoInternalPostLoad(); |
| } |
| else |
| { |
| changeState(object, CDOState.PROXY); |
| |
| CDOInvalidationPolicy policy = view.options().getInvalidationPolicy(); |
| policy.handleInvalidation(object, key); |
| |
| object.cdoInternalPostInvalidate(); |
| } |
| } |
| } |
| |
| private CDOBranchVersion getNewBranchVersion(CDORevisionKey key, CDOBranch viewBranch) |
| { |
| if (key != null) |
| { |
| CDOBranch keyBranch = key.getBranch(); |
| |
| if (key instanceof CDORevisionDelta) |
| { |
| CDORevisionDelta delta = (CDORevisionDelta)key; |
| CDORevisable target = delta.getTarget(); |
| if (target != null && keyBranch == target.getBranch()) |
| { |
| return target; |
| } |
| } |
| |
| if (keyBranch == viewBranch) |
| { |
| return keyBranch.getVersion(key.getVersion() + 1); |
| } |
| |
| return viewBranch.getVersion(CDOBranchVersion.FIRST_VERSION); |
| } |
| |
| return null; |
| } |
| } |
| |
| /** |
| * @author Eike Stepper |
| */ |
| private class ConflictTransition extends InvalidateTransition |
| { |
| @Override |
| public void execute(InternalCDOObject object, CDOState state, CDOEvent event, CDORevisionKey key) |
| { |
| InternalCDORevision oldRevision = object.cdoRevision(); |
| if (key == null || key.getVersion() >= oldRevision.getVersion() - 1) |
| { |
| changeState(object, CDOState.CONFLICT); |
| InternalCDOTransaction transaction = object.cdoView().toTransaction(); |
| transaction.setConflict(object); |
| } |
| } |
| } |
| |
| /** |
| * @author Simon McDuff |
| */ |
| private final class InvalidConflictTransition extends ConflictTransition |
| { |
| @Override |
| public void execute(InternalCDOObject object, CDOState state, CDOEvent event, CDORevisionKey UNUSED) |
| { |
| changeState(object, CDOState.INVALID_CONFLICT); |
| |
| InternalCDOTransaction transaction = object.cdoView().toTransaction(); |
| transaction.setConflict(object); |
| } |
| } |
| |
| /** |
| * @author Eike Stepper |
| */ |
| private final class LoadTransition implements ITransition<CDOState, CDOEvent, InternalCDOObject, Object> |
| { |
| public void execute(InternalCDOObject object, CDOState state, CDOEvent event, Object UNUSED) |
| { |
| internalLoad(object, false); |
| } |
| } |
| |
| /** |
| * @author Simon McDuff |
| */ |
| private static final class InvalidTransition implements ITransition<CDOState, CDOEvent, InternalCDOObject, Object> |
| { |
| public static final InvalidTransition INSTANCE = new InvalidTransition(); |
| |
| public void execute(InternalCDOObject object, CDOState state, CDOEvent event, Object NULL) |
| { |
| InternalCDOView view = object.cdoView(); |
| CDOInvalidationPolicy policy = view.options().getInvalidationPolicy(); |
| policy.handleInvalidObject(object); |
| } |
| } |
| } |
| |
| /** |
| * @author Eike Stepper |
| */ |
| enum CDOEvent |
| { |
| PREPARE, ATTACH, DETACH, REATTACH, READ, WRITE, INVALIDATE, DETACH_REMOTE, COMMIT, ROLLBACK |
| } |
