Attachment #178678 for bug #312535

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 56-59 Link Here

(-)src/org/eclipse/emf/cdo/transaction/CDOCommitContext.java (+5 lines)
56	* Returns a map of the {@link CDORevisionDelta revision deltas} that are to be committed with this commit context.	56	* Returns a map of the {@link CDORevisionDelta revision deltas} that are to be committed with this commit context.
57	*/	57	*/
58	public Map<CDOID, CDORevisionDelta> getRevisionDeltas();	58	public Map<CDOID, CDORevisionDelta> getRevisionDeltas();
		59
		60	/**
		61	* @since 4.0
		62	*/
		63	public boolean isPartialCommit();
59	}	64	}




  {
    delegate.setCommitComment(comment);
  }

  /**
   * @since 4.0
   */
  public void setCommittables(Set<EObject> committables)
  {
    delegate.setCommittables(committables);
  }

  /**
   * @since 4.0
   */
  public Set<EObject> getCommittables()
  {
    return delegate.getCommittables();
  }
}

Lines 14-21 Link Here

(-)src/org/eclipse/emf/cdo/transaction/CDOUserTransaction.java (+14 lines)
14	import org.eclipse.emf.cdo.common.commit.CDOCommitInfo;	14	import org.eclipse.emf.cdo.common.commit.CDOCommitInfo;
15	import org.eclipse.emf.cdo.util.CommitException;	15	import org.eclipse.emf.cdo.util.CommitException;
16		16
		17	import org.eclipse.emf.ecore.EObject;
		18
17	import org.eclipse.core.runtime.IProgressMonitor;	19	import org.eclipse.core.runtime.IProgressMonitor;
18		20
		21	import java.util.Set;
		22
19	/**	23	/**
20	* Only deal with transaction process.	24	* Only deal with transaction process.
21	*	25	*
Lines 50-53 Link Here
50	* @since 3.0	54	* @since 3.0
51	*/	55	*/
52	public CDOUserSavepoint getLastSavepoint();	56	public CDOUserSavepoint getLastSavepoint();
		57
		58	/**
		59	* @since 4.0
		60	*/
		61	public void setCommittables(Set<EObject> committables);
		62
		63	/**
		64	* @since 4.0
		65	*/
		66	public Set<EObject> getCommittables();
53	}	67	}




/**
 * Copyright (c) 2004 - 2010 Eike Stepper (Berlin, 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:
 *    Caspar De Groot - initial API and implementation
 */
package org.eclipse.emf.cdo.util;

import org.eclipse.emf.cdo.CDOObject;
import org.eclipse.emf.cdo.common.id.CDOID;
import org.eclipse.emf.cdo.common.id.CDOID.Type;
import org.eclipse.emf.cdo.common.revision.delta.CDOAddFeatureDelta;
import org.eclipse.emf.cdo.common.revision.delta.CDOClearFeatureDelta;
import org.eclipse.emf.cdo.common.revision.delta.CDOContainerFeatureDelta;
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.CDORemoveFeatureDelta;
import org.eclipse.emf.cdo.common.revision.delta.CDORevisionDelta;
import org.eclipse.emf.cdo.common.revision.delta.CDORevisionDeltaUtil;
import org.eclipse.emf.cdo.common.revision.delta.CDOSetFeatureDelta;
import org.eclipse.emf.cdo.common.revision.delta.CDOUnsetFeatureDelta;
import org.eclipse.emf.cdo.eresource.CDOResource;
import org.eclipse.emf.cdo.spi.common.revision.InternalCDORevision;

import org.eclipse.net4j.util.CheckUtil;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject.EStore;
import org.eclipse.emf.spi.cdo.InternalCDOObject;
import org.eclipse.emf.spi.cdo.InternalCDOTransaction;
import org.eclipse.emf.spi.cdo.InternalCDOTransaction.InternalCDOCommitContext;

import java.util.HashSet;
import java.util.Set;

/**
 * @author Caspar De Groot
 * @since 4.0
 */
public class CommitIntegrityCheck
{
  private InternalCDOTransaction transaction;

  private Style style;

  private Set<CDOID> newIDs, dirtyIDs, detachedIDs;

  private Set<CDOObject> missingObjects = new HashSet<CDOObject>();

  private StringBuilder exceptionMessage = new StringBuilder();

  public CommitIntegrityCheck(InternalCDOCommitContext commitContext)
  {
    this(commitContext, Style.EXCEPTION_FAST);
  }

  public CommitIntegrityCheck(InternalCDOCommitContext commitContext, Style style)
  {
    transaction = commitContext.getTransaction();

    CheckUtil.checkNull(style, "style should not be null");
    this.style = style;

    newIDs = commitContext.getNewObjects().keySet();
    dirtyIDs = commitContext.getDirtyObjects().keySet();
    detachedIDs = commitContext.getDetachedObjects().keySet();
  }

  public void check() throws CommitIntegrityException
  {
    // For new objects: ensure that their container is included,
    // as well as the targets of the new object's bidi references
    for (CDOID newID : newIDs)
    {
      CDOObject newObject = transaction.getObject(newID);
      checkContainerIncluded(newObject, "new");
      checkCurrentBidiRefTargetsIncluded(newObject, "new");
    }

    // For detached objects: ensure that their former container is included,
    // as well as the targets of the detached object's bidi references
    for (CDOID detachedID : detachedIDs)
    {
      CDOObject detachedObject = transaction.getObject(detachedID);
      checkFormerContainerIncluded(detachedObject);
      checkFormerBidiRefTargetsIncluded(detachedObject, "detached");
    }

    // For dirty objects: if any of the deltas for the object, affect containment (i.e. object was moved)
    // or a bi-di reference, ensure that for containment, both the old and new containers are included,
    // (or that the child is included if we are considering the dirty parent),
    // and that for a bi-di reference, the object holding the other end of the bi-di is included, as
    // well as possibly the *former* object holding the other end.
    //
    for (CDOID dirtyID : dirtyIDs)
    {
      CDOObject dirtyObject = transaction.getObject(dirtyID);
      analyzeRevisionDelta((InternalCDOObject)dirtyObject);
    }

    if (!missingObjects.isEmpty() && style == Style.EXCEPTION)
    {
      throw createException();
    }
  }

  public Set<? extends EObject> getMissingObjects()
  {
    return missingObjects;
  }

  private CDOID getContainerOrResourceID(InternalCDORevision revision)
  {
    CDOID containerOrResourceID = null;
    Object idOrObject = revision.getContainerID();
    if (idOrObject != null)
    {
      containerOrResourceID = (CDOID)transaction.convertObjectToID(idOrObject);
    }

    if (containerOrResourceID == null || containerOrResourceID.getType() == Type.NULL)
    {
      idOrObject = revision.getResourceID();
      if (idOrObject != null)
      {
        containerOrResourceID = (CDOID)transaction.convertObjectToID(idOrObject);
      }
    }

    return containerOrResourceID;
  }

  private void analyzeRevisionDelta(InternalCDOObject dirtyObject) throws CommitIntegrityException
  {
    // Getting the deltas from the TX is not a good idea...
    // We better recompute a fresh delta:
    //
    InternalCDORevision cleanRev = transaction.getCleanRevisions().get(dirtyObject);
    CheckUtil.checkNull(cleanRev, "Could not obtain clean revision for dirty object " + dirtyObject);
    InternalCDORevision dirtyRev = dirtyObject.cdoRevision();
    CDORevisionDelta rDelta = CDORevisionDeltaUtil.create(cleanRev, dirtyRev);

    for (CDOFeatureDelta featureDelta : rDelta.getFeatureDeltas())
    {
      EStructuralFeature feat = featureDelta.getFeature();
      if (feat == CDOContainerFeatureDelta.CONTAINER_FEATURE)
      {
        // Object is dirty with respect to its container; this means it was moved;
        // We must ensure that both the old and new containers are included
        checkContainerIncluded(dirtyObject, "moved");
        CDOID containerOrResourceID = getContainerOrResourceID(cleanRev);
        checkIncluded(containerOrResourceID, "former container (or resource) of moved", dirtyObject);
      }
      else if (feat instanceof EReference)
      {
        EReference ref = (EReference)feat;
        if (ref.isContainment() || ref.getEOpposite() != null)
        {
          // Object is dirty with respect to a containment feature
          // We must ensure that any children that were added/removed, are also
          // included in the commit

          if (featureDelta instanceof CDOListFeatureDelta)
          {
            for (CDOFeatureDelta innerFeatDelta : ((CDOListFeatureDelta)featureDelta).getListChanges())
            {
              checkContainmentDelta(innerFeatDelta, dirtyObject);
            }
          }
          else
          {
            checkContainmentDelta(featureDelta, dirtyObject);
          }
        }
      }
    }
  }

  private void checkContainmentDelta(CDOFeatureDelta featureDelta, CDOObject dirtyObject)
      throws CommitIntegrityException
  {
    if (featureDelta instanceof CDORemoveFeatureDelta)
    {
      Object idOrObject = ((CDORemoveFeatureDelta)featureDelta).getValue();
      CDOID id = (CDOID)transaction.convertObjectToID(idOrObject);
      checkIncluded(id, "removed child of", dirtyObject);
    }
    else if (featureDelta instanceof CDOAddFeatureDelta)
    {
      Object idOrObject = ((CDOAddFeatureDelta)featureDelta).getValue();
      CDOID id = (CDOID)transaction.convertObjectToID(idOrObject);
      if (id.getType() != CDOID.Type.NULL)
      {
        checkIncluded(id, "added child of", dirtyObject);
      }
    }
    else if (featureDelta instanceof CDOSetFeatureDelta)
    {
      Object newIDOrObject = ((CDOSetFeatureDelta)featureDelta).getValue();
      Object oldIDOrObject = ((CDOSetFeatureDelta)featureDelta).getOldValue();
      CDOID oldID = (CDOID)transaction.convertObjectToID(oldIDOrObject);
      if (oldIDOrObject != null)
      {
        if (newIDOrObject == null)
        {
          // Removal: old child must be included
          checkIncluded(oldID, "removed child of", dirtyObject);
        }
        else
        {
          // Change: both old and new child must be included
          checkIncluded(oldID, "former child of", dirtyObject);
          CDOID newID = (CDOID)transaction.convertObjectToID(newIDOrObject);
          checkIncluded(newID, "new child of", dirtyObject);
        }
      }
      else
      {
        // New child, no old child
        CDOID newID = (CDOID)transaction.convertObjectToID(newIDOrObject);
        checkIncluded(newID, "new child of", dirtyObject);
      }
    }
    else if (featureDelta instanceof CDOClearFeatureDelta)
    {
      EStructuralFeature feat = ((CDOClearFeatureDelta)featureDelta).getFeature();
      InternalCDORevision cleanRev = transaction.getCleanRevisions().get(dirtyObject);
      int n = cleanRev.size(feat);
      for (int i = 0; i < n; i++)
      {
        Object idOrObject = cleanRev.get(feat, i);
        CDOID id = (CDOID)transaction.convertObjectToID(idOrObject);
        checkIncluded(id, "removed child of", dirtyObject);
      }
    }
    else if (featureDelta instanceof CDOUnsetFeatureDelta)
    {
      EStructuralFeature feat = ((CDOUnsetFeatureDelta)featureDelta).getFeature();
      InternalCDORevision cleanRev = transaction.getCleanRevisions().get(dirtyObject);
      Object idOrObject = cleanRev.getValue(feat);
      CDOID id = (CDOID)transaction.convertObjectToID(idOrObject);
      checkIncluded(id, "removed child of", dirtyObject);
    }
    else
    {
      throw new RuntimeException("Unexpected delta type: " + featureDelta.getClass().getSimpleName());
    }
  }

  private void checkIncluded(CDOID id, String msg, CDOObject o) throws CommitIntegrityException
  {
    if (id.getType() == Type.NULL)
    {
      throw new IllegalArgumentException("CDOID must not be of type NULL");
    }

    if (!dirtyIDs.contains(id) && !detachedIDs.contains(id) && !newIDs.contains(id))
    {
      CDOObject missingObject = transaction.getObject(id);
      if (missingObject == null)
      {
        throw new IllegalStateException("Could not find object for CDOID " + id);
      }
      missingObjects.add(missingObject);

      if (exceptionMessage.length() > 0)
      {
        exceptionMessage.append('\n');
      }
      String m = String.format("The %s object %s needs to be included in the commit but isn't", msg, o);
      exceptionMessage.append(m);

      if (style == Style.EXCEPTION_FAST)
      {
        throw createException();
      }
    }
  }

  private CommitIntegrityException createException()
  {
    return new CommitIntegrityException(exceptionMessage.toString(), missingObjects);
  }

  /**
   * Checks whether the container of a given object is included in the commit
   * 
   * @param msgFrag
   * @throws CommitIntegrityException
   */
  private void checkContainerIncluded(CDOObject object, String msgFrag) throws CommitIntegrityException
  {
    EObject eContainer = object.eContainer();
    if (eContainer == null)
    {
      // It's a top-level object
      CDOResource resource = object.cdoDirectResource();
      checkIncluded(resource.cdoID(), "resource of " + msgFrag, object);
    }
    else
    {
      CDOObject container = CDOUtil.getCDOObject(eContainer);
      checkIncluded(container.cdoID(), "container of " + msgFrag, object);
    }
  }

  private void checkCurrentBidiRefTargetsIncluded(CDOObject referencer, String msgFrag) throws CommitIntegrityException
  {
    for (EReference eRef : referencer.eClass().getEAllReferences())
    {
      if (eRef.getEOpposite() != null)
      {
        if (eRef.isMany())
        {
          EList<?> list = (EList<?>)referencer.eGet(eRef);
          for (Object element : list)
          {
            checkBidiRefTargetIncluded(element, referencer, msgFrag);
          }
        }
        else
        {
          Object refTarget = referencer.eGet(eRef);
          if (refTarget != null)
          {
            checkBidiRefTargetIncluded(refTarget, referencer, msgFrag);
          }
        }
      }
    }
  }

  private void checkFormerBidiRefTargetsIncluded(CDOObject referencer, String msgFrag) throws CommitIntegrityException
  {
    // The referencer argument should really be a detached object, and so we know
    // that we can find the pre-detach revision in tx.getFormerRevisions(). However,
    // the object may have already been dirty prior to detachment, so we check the
    // clean revisions first.
    //
    InternalCDORevision cleanRev = transaction.getCleanRevisions().get(referencer);
    CheckUtil.checkState(cleanRev, "cleanRev");

    for (EReference eRef : referencer.eClass().getEAllReferences())
    {
      if (eRef.getEOpposite() != null)
      {
        Object value = cleanRev.get(eRef, EStore.NO_INDEX);
        if (value != null)
        {
          if (eRef.isMany())
          {
            EList<?> list = (EList<?>)value;
            for (Object element : list)
            {
              checkBidiRefTargetIncluded(element, referencer, msgFrag);
            }
          }
          else
          {
            checkBidiRefTargetIncluded(value, referencer, msgFrag);
          }
        }
      }
    }
  }

  private void checkBidiRefTargetIncluded(Object refTarget, CDOObject referencer, String msgFrag)
      throws CommitIntegrityException
  {
    CheckUtil.checkArg(refTarget, "refTarget");
    CDOID refTargetID = null;
    if (refTarget instanceof EObject)
    {
      refTargetID = CDOUtil.getCDOObject((EObject)refTarget).cdoID();
    }
    else if (refTarget instanceof CDOID)
    {
      refTargetID = (CDOID)refTarget;
    }
    checkIncluded(refTargetID, "reference target of " + msgFrag, referencer);
  }

  private void checkFormerContainerIncluded(CDOObject detachedObject) throws CommitIntegrityException
  {
    InternalCDORevision rev = transaction.getCleanRevisions().get(detachedObject);
    CheckUtil.checkNull(rev, "Could not obtain clean revision for detached object " + detachedObject);
    CDOID id = getContainerOrResourceID(rev);
    checkIncluded(id, "former container (or resource) of detached", detachedObject);
  }

  /**
   * Designates an exception style for a {@link CommitIntegrityCheck}
   * 
   * @author Caspar De Groot
   */
  public enum Style
  {
    /**
     * Throw an exception as soon as this {@link CommitIntegrityCheck} encounters the first problem
     */
    EXCEPTION_FAST,

    /**
     * Throw an exception when this {@link CommitIntegrityCheck} finishes performing all possible checks, in case any
     * problems were found
     */
    EXCEPTION,

    /**
     * Do not throw an exception. Caller must invoke {@link CommitIntegrityCheck#getMissingObjects()} to find out if the
     * check discovered any problems.
     */
    NO_EXCEPTION
  }
}




/**
 * Copyright (c) 2004 - 2010 Eike Stepper (Berlin, 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:
 *    Caspar De Groot - initial API and implementation
 */
package org.eclipse.emf.cdo.util;

import org.eclipse.emf.ecore.EObject;

import java.util.Set;

/**
 * @author Caspar De Groot
 * @since 4.0
 */
public class CommitIntegrityException extends CommitException
{
  private static final long serialVersionUID = 3302652235940254454L;

  private Set<? extends EObject> missingObjects;

  public CommitIntegrityException(String msg, Set<? extends EObject> missingObjects)
  {
    super(msg);
    this.missingObjects = missingObjects;
  }

  public Set<? extends EObject> getMissingObjects()
  {
    return missingObjects;
  }
}

Lines 798-803 Link Here

(-)src/org/eclipse/emf/internal/cdo/CDOStateMachine.java (+2 lines)
798	public void execute(InternalCDOObject object, CDOState state, CDOEvent event, Object featureDelta)	798	public void execute(InternalCDOObject object, CDOState state, CDOEvent event, Object featureDelta)
799	{	799	{
800	InternalCDOTransaction transaction = object.cdoView().toTransaction();	800	InternalCDOTransaction transaction = object.cdoView().toTransaction();
		801	InternalCDORevision cleanRevision = object.cdoRevision();
		802	transaction.getCleanRevisions().put(object, cleanRevision);
801		803
802	// Copy revision	804	// Copy revision
803	InternalCDORevision revision = object.cdoRevision().copy();	805	InternalCDORevision revision = object.cdoRevision().copy();

Lines 69-74 Link Here

(-)src/org/eclipse/emf/internal/cdo/transaction/CDOTransactionImpl.java (-24 / +148 lines)
69	import org.eclipse.emf.cdo.spi.common.revision.InternalCDORevisionDelta;	69	import org.eclipse.emf.cdo.spi.common.revision.InternalCDORevisionDelta;
70	import org.eclipse.emf.cdo.spi.common.revision.InternalCDORevisionManager;	70	import org.eclipse.emf.cdo.spi.common.revision.InternalCDORevisionManager;
71	import org.eclipse.emf.cdo.spi.common.revision.PointerCDORevision;	71	import org.eclipse.emf.cdo.spi.common.revision.PointerCDORevision;
		72	import org.eclipse.emf.cdo.transaction.CDOCommitContext;
72	import org.eclipse.emf.cdo.transaction.CDOConflictResolver;	73	import org.eclipse.emf.cdo.transaction.CDOConflictResolver;
73	import org.eclipse.emf.cdo.transaction.CDOConflictResolver2;	74	import org.eclipse.emf.cdo.transaction.CDOConflictResolver2;
74	import org.eclipse.emf.cdo.transaction.CDODefaultTransactionHandler;	75	import org.eclipse.emf.cdo.transaction.CDODefaultTransactionHandler;
Lines 83-88 Link Here
83	import org.eclipse.emf.cdo.util.CDOURIUtil;	84	import org.eclipse.emf.cdo.util.CDOURIUtil;
84	import org.eclipse.emf.cdo.util.CDOUtil;	85	import org.eclipse.emf.cdo.util.CDOUtil;
85	import org.eclipse.emf.cdo.util.CommitException;	86	import org.eclipse.emf.cdo.util.CommitException;
		87	import org.eclipse.emf.cdo.util.CommitIntegrityCheck;
86	import org.eclipse.emf.cdo.util.LegacyModeNotEnabledException;	88	import org.eclipse.emf.cdo.util.LegacyModeNotEnabledException;
87	import org.eclipse.emf.cdo.util.ObjectNotFoundException;	89	import org.eclipse.emf.cdo.util.ObjectNotFoundException;
88		90
Lines 191-196 Link Here
191	}	193	}
192	};	194	};
193		195
		196	private Set<EObject> committables;
		197
		198	private Map<InternalCDOObject, InternalCDORevision> cleanRevisions = new HashMap<InternalCDOObject, InternalCDORevision>();
		199
194	public CDOTransactionImpl(CDOBranch branch)	200	public CDOTransactionImpl(CDOBranch branch)
195	{	201	{
196	super(branch, UNSPECIFIED_DATE);	202	super(branch, UNSPECIFIED_DATE);
Lines 978-984 Link Here
978	{	984	{
979	checkActive();	985	checkActive();
980	rollback(firstSavepoint);	986	rollback(firstSavepoint);
981	cleanUp();	987	cleanUp(null);
982	}	988	}
983		989
984	private void removeObject(CDOID id, CDOObject object)	990	private void removeObject(CDOID id, CDOObject object)
Lines 1203-1208 Link Here
1203	formerRevisionKeys.put(object, revKey);	1209	formerRevisionKeys.put(object, revKey);
1204	}	1210	}
1205		1211
		1212	if (!cleanRevisions.containsKey(object))
		1213	{
		1214	cleanRevisions.put(object, object.cdoRevision());
		1215	}
		1216
1206	// Object may have been reattached previously, in which case it must	1217	// Object may have been reattached previously, in which case it must
1207	// here be removed from the collection of reattached objects	1218	// here be removed from the collection of reattached objects
1208	lastSavepoint.getReattachedObjects().remove(id);	1219	lastSavepoint.getReattachedObjects().remove(id);
Lines 1551-1569 Link Here
1551	return newPackages;	1562	return newPackages;
1552	}	1563	}
1553		1564
1554	private void cleanUp()	1565	private void cleanUp(CDOCommitContext commitContext)
1555	{	1566	{
1556	lastSavepoint = firstSavepoint;	1567	if (commitContext == null \|\| !commitContext.isPartialCommit())
1557	firstSavepoint.clear();	1568	{
1558	firstSavepoint.setNextSavepoint(null);	1569	lastSavepoint = firstSavepoint;
1559	firstSavepoint.getSharedDetachedObjects().clear();	1570	firstSavepoint.clear();
1560		1571	firstSavepoint.setNextSavepoint(null);
1561	// Bug 283985 (Re-attachment)	1572	firstSavepoint.getSharedDetachedObjects().clear();
1562	formerRevisionKeys.clear();	1573
1563		1574	// Bug 283985 (Re-attachment)
1564	dirty = false;	1575	formerRevisionKeys.clear();
1565	conflict = 0;	1576
1566	lastTemporaryID.set(0);	1577	cleanRevisions.clear();
		1578	dirty = false;
		1579	conflict = 0;
		1580	lastTemporaryID.set(0);
		1581	}
		1582	else
		1583	{
		1584	collapseSavepoints(commitContext);
		1585
		1586	for (CDOObject object : commitContext.getDetachedObjects().values())
		1587	{
		1588	formerRevisionKeys.remove(object);
		1589	}
		1590	}
		1591
		1592	// Reset partial-commit filter
		1593	committables = null;
		1594	}
		1595
		1596	private void collapseSavepoints(CDOCommitContext commitContext)
		1597	{
		1598	InternalCDOSavepoint newSavepoint = createSavepoint(null);
		1599	copyUncommitted(lastSavepoint.getAllNewObjects(), commitContext.getNewObjects(), newSavepoint.getNewObjects());
		1600	copyUncommitted(lastSavepoint.getAllDirtyObjects(), commitContext.getDirtyObjects(), newSavepoint.getDirtyObjects());
		1601	copyUncommitted(lastSavepoint.getAllRevisionDeltas(), commitContext.getRevisionDeltas(),
		1602	newSavepoint.getRevisionDeltas());
		1603	copyUncommitted(lastSavepoint.getAllDetachedObjects(), commitContext.getDetachedObjects(),
		1604	newSavepoint.getDetachedObjects());
		1605	lastSavepoint = newSavepoint;
		1606	firstSavepoint = lastSavepoint;
		1607	}
		1608
		1609	private <T> void copyUncommitted(Map<CDOID, T> oldSavepointMap, Map<CDOID, T> commitContextMap,
		1610	Map<CDOID, T> newSavepointMap)
		1611	{
		1612	for (Entry<CDOID, T> entry : oldSavepointMap.entrySet())
		1613	{
		1614	if (!commitContextMap.containsKey(entry.getKey()))
		1615	{
		1616	newSavepointMap.put(entry.getKey(), entry.getValue());
		1617	}
		1618	}
1567	}	1619	}
1568		1620
1569	public CDOSavepoint[] exportChanges(OutputStream stream) throws IOException	1621	public CDOSavepoint[] exportChanges(OutputStream stream) throws IOException
Lines 1925-1930 Link Here
1925	commitComment = comment;	1977	commitComment = comment;
1926	}	1978	}
1927		1979
		1980	public void setCommittables(Set<EObject> committables)
		1981	{
		1982	this.committables = committables;
		1983	}
		1984
		1985	public Set<EObject> getCommittables()
		1986	{
		1987	return committables;
		1988	}
		1989
		1990	public Map<InternalCDOObject, InternalCDORevision> getCleanRevisions()
		1991	{
		1992	return cleanRevisions;
		1993	}
		1994
1928	/**	1995	/**
1929	* @author Simon McDuff	1996	* @author Simon McDuff
1930	*/	1997	*/
Lines 1934-1939 Link Here
1934		2001
1935	private CDOCommitData commitData;	2002	private CDOCommitData commitData;
1936		2003
		2004	private Map<CDOID, CDOObject> newObjects;
		2005
		2006	private Map<CDOID, CDOObject> detachedObjects;
		2007
		2008	private Map<CDOID, CDORevisionDelta> revisionDeltas;
		2009
		2010	private Map<CDOID, CDOObject> dirtyObjects;
		2011
		2012	/**
		2013	* Tracks whether this commit is actually partial or not. (Having tx.committables != null does not in itself mean
		2014	* that the commit will be partial, because the committables could cover all dirty/new/detached objects. But this
		2015	* boolean gets set to reflect whether the commit will really commit less than all dirty/new/detached objects.)
		2016	*/
		2017	private boolean isPartialCommit;
		2018
1937	public CDOCommitContextImpl(InternalCDOTransaction transaction)	2019	public CDOCommitContextImpl(InternalCDOTransaction transaction)
1938	{	2020	{
1939	this.transaction = transaction;	2021	this.transaction = transaction;
Lines 1943-1971 Link Here
1943	private void calculateCommitData()	2025	private void calculateCommitData()
1944	{	2026	{
1945	List<CDOPackageUnit> newPackageUnits = analyzeNewPackages();	2027	List<CDOPackageUnit> newPackageUnits = analyzeNewPackages();
1946	List<CDOIDAndVersion> revisions = new ArrayList<CDOIDAndVersion>(getNewObjects().size());	2028	newObjects = filterCommittables(transaction.getNewObjects());
1947	for (CDOObject newObject : getNewObjects().values())	2029	List<CDOIDAndVersion> revisions = new ArrayList<CDOIDAndVersion>(newObjects.size());
		2030	for (CDOObject newObject : newObjects.values())
1948	{	2031	{
1949	revisions.add(newObject.cdoRevision());	2032	revisions.add(newObject.cdoRevision());
1950	}	2033	}
1951		2034
1952	List<CDORevisionKey> deltas = new ArrayList<CDORevisionKey>(getRevisionDeltas().size());	2035	revisionDeltas = filterCommittables(transaction.getRevisionDeltas());
1953	for (CDORevisionDelta delta : getRevisionDeltas().values())	2036	List<CDORevisionKey> deltas = new ArrayList<CDORevisionKey>(revisionDeltas.size());
		2037	for (CDORevisionDelta delta : revisionDeltas.values())
1954	{	2038	{
1955	deltas.add(delta);	2039	deltas.add(delta);
1956	}	2040	}
1957		2041
1958	List<CDOIDAndVersion> detached = new ArrayList<CDOIDAndVersion>(getDetachedObjects().size());	2042	detachedObjects = filterCommittables(transaction.getDetachedObjects());
1959	for (CDOID id : getDetachedObjects().keySet())	2043	List<CDOIDAndVersion> detached = new ArrayList<CDOIDAndVersion>(detachedObjects.size());
		2044	for (CDOID id : detachedObjects.keySet())
1960	{	2045	{
1961	// Add "version-less" key.	2046	// Add "version-less" key.
1962	// CDOSessionImpl.reviseRevisions() will call reviseLatest() accordingly.	2047	// CDOSessionImpl.reviseRevisions() will call reviseLatest() accordingly.
1963	detached.add(CDOIDUtil.createIDAndVersion(id, CDOBranchVersion.UNSPECIFIED_VERSION));	2048	detached.add(CDOIDUtil.createIDAndVersion(id, CDOBranchVersion.UNSPECIFIED_VERSION));
1964	}	2049	}
1965		2050
		2051	dirtyObjects = filterCommittables(transaction.getDirtyObjects());
		2052
1966	commitData = new CDOCommitDataImpl(newPackageUnits, revisions, deltas, detached);	2053	commitData = new CDOCommitDataImpl(newPackageUnits, revisions, deltas, detached);
1967	}	2054	}
1968		2055
		2056	private <T> Map<CDOID, T> filterCommittables(Map<CDOID, T> map)
		2057	{
		2058	if (committables == null)
		2059	{
		2060	// No partial commit filter -- nothing to do
		2061	return map;
		2062	}
		2063
		2064	Map<CDOID, T> newMap = new HashMap<CDOID, T>();
		2065	for (CDOID id : map.keySet())
		2066	{
		2067	CDOObject o = getObject(id);
		2068	if (committables.contains(o))
		2069	{
		2070	newMap.put(id, map.get(id));
		2071	}
		2072	else
		2073	{
		2074	isPartialCommit = true;
		2075	}
		2076	}
		2077
		2078	return newMap;
		2079	}
		2080
1969	public InternalCDOTransaction getTransaction()	2081	public InternalCDOTransaction getTransaction()
1970	{	2082	{
1971	return transaction;	2083	return transaction;
Lines 1978-1989 Link Here
1978		2090
1979	public Map<CDOID, CDOObject> getDirtyObjects()	2091	public Map<CDOID, CDOObject> getDirtyObjects()
1980	{	2092	{
1981	return transaction.getDirtyObjects();	2093	return dirtyObjects;
1982	}	2094	}
1983		2095
1984	public Map<CDOID, CDOObject> getNewObjects()	2096	public Map<CDOID, CDOObject> getNewObjects()
1985	{	2097	{
1986	return transaction.getNewObjects();	2098	return newObjects;
1987	}	2099	}
1988		2100
1989	public List<CDOPackageUnit> getNewPackageUnits()	2101	public List<CDOPackageUnit> getNewPackageUnits()
Lines 1993-2004 Link Here
1993		2105
1994	public Map<CDOID, CDOObject> getDetachedObjects()	2106	public Map<CDOID, CDOObject> getDetachedObjects()
1995	{	2107	{
1996	return transaction.getDetachedObjects();	2108	return detachedObjects;
1997	}	2109	}
1998		2110
1999	public Map<CDOID, CDORevisionDelta> getRevisionDeltas()	2111	public Map<CDOID, CDORevisionDelta> getRevisionDeltas()
2000	{	2112	{
2001	return transaction.getRevisionDeltas();	2113	return revisionDeltas;
2002	}	2114	}
2003		2115
2004	public void preCommit()	2116	public void preCommit()
Lines 2046-2051 Link Here
2046		2158
2047	try	2159	try
2048	{	2160	{
		2161	// TODO (CD) It might be better to always do the checks,
		2162	// instead of only for partial commits
		2163	if (isPartialCommit)
		2164	{
		2165	new CommitIntegrityCheck(this, CommitIntegrityCheck.Style.EXCEPTION_FAST).check();
		2166	}
		2167
2049	preCommit(getNewObjects());	2168	preCommit(getNewObjects());
2050	preCommit(getDirtyObjects());	2169	preCommit(getDirtyObjects());
2051	}	2170	}
Lines 2110-2116 Link Here
2110	getChangeSubscriptionManager().committedTransaction(transaction, this);	2229	getChangeSubscriptionManager().committedTransaction(transaction, this);
2111	getAdapterManager().committedTransaction(transaction, this);	2230	getAdapterManager().committedTransaction(transaction, this);
2112		2231
2113	cleanUp();	2232	cleanUp(this);
2114	Map<CDOID, CDOID> idMappings = result.getIDMappings();	2233	Map<CDOID, CDOID> idMappings = result.getIDMappings();
2115	IListener[] listeners = getListeners();	2234	IListener[] listeners = getListeners();
2116	if (listeners != null)	2235	if (listeners != null)
Lines 2180-2185 Link Here
2180	}	2299	}
2181	}	2300	}
2182	}	2301	}
		2302
		2303	public boolean isPartialCommit()
		2304	{
		2305	return isPartialCommit;
		2306	}
2183	}	2307	}
2184		2308
2185	/**	2309	/**

Lines 134-139 Link Here

(-)src/org/eclipse/emf/internal/cdo/transaction/CDOXACommitContextImpl.java (+5 lines)
134	return delegateCommitContext.getCommitData();	134	return delegateCommitContext.getCommitData();
135	}	135	}
136		136
		137	public boolean isPartialCommit()
		138	{
		139	return delegateCommitContext.isPartialCommit();
		140	}
		141
137	public Object call() throws Exception	142	public Object call() throws Exception
138	{	143	{
139	state.handle(this, progressMonitor);	144	state.handle(this, progressMonitor);




import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.spi.cdo.CDOSessionProtocol;
import org.eclipse.emf.spi.cdo.CDOSessionProtocol.CommitTransactionResult;
import org.eclipse.emf.spi.cdo.CDOTransactionStrategy;

    }
  }

  public void setCommittables(Set<EObject> committables)
  {
    throw new UnsupportedOperationException();
  }

  public Set<EObject> getCommittables()
  {
    throw new UnsupportedOperationException();
  }

  /**
   * @author Simon McDuff
   */

Lines 20-25 Link Here

(-)src/org/eclipse/emf/spi/cdo/InternalCDOTransaction.java (+6 lines)
20	import org.eclipse.emf.cdo.common.revision.delta.CDOFeatureDelta;	20	import org.eclipse.emf.cdo.common.revision.delta.CDOFeatureDelta;
21	import org.eclipse.emf.cdo.common.revision.delta.CDORevisionDelta;	21	import org.eclipse.emf.cdo.common.revision.delta.CDORevisionDelta;
22	import org.eclipse.emf.cdo.eresource.CDOResourceFolder;	22	import org.eclipse.emf.cdo.eresource.CDOResourceFolder;
		23	import org.eclipse.emf.cdo.spi.common.revision.InternalCDORevision;
23	import org.eclipse.emf.cdo.transaction.CDOCommitContext;	24	import org.eclipse.emf.cdo.transaction.CDOCommitContext;
24	import org.eclipse.emf.cdo.transaction.CDOTransaction;	25	import org.eclipse.emf.cdo.transaction.CDOTransaction;
25		26
Lines 92-97 Link Here
92	public Map<InternalCDOObject, CDORevisionKey> getFormerRevisionKeys();	93	public Map<InternalCDOObject, CDORevisionKey> getFormerRevisionKeys();
93		94
94	/**	95	/**
		96	* @since 4.0
		97	*/
		98	public Map<InternalCDOObject, InternalCDORevision> getCleanRevisions();
		99
		100	/**
95	* Provides a context for a commit operation.	101	* Provides a context for a commit operation.
96	*	102	*
97	* @author Simon McDuff	103	* @author Simon McDuff

Lines 17-23 Link Here

(-)src/org/eclipse/emf/cdo/common/revision/delta/CDOSetFeatureDelta.java (+10 lines)
17	*/	17	*/
18	public interface CDOSetFeatureDelta extends CDOFeatureDelta	18	public interface CDOSetFeatureDelta extends CDOFeatureDelta
19	{	19	{
		20	/**
		21	* @since 4.0
		22	*/
		23	public static final Object UNSPECIFIED = new Object();
		24
20	public int getIndex();	25	public int getIndex();
21		26
22	public Object getValue();	27	public Object getValue();
		28
		29	/**
		30	* @since 4.0
		31	*/
		32	public Object getOldValue();
23	}	33	}

Lines 364-370 Link Here

(-)src/org/eclipse/emf/cdo/internal/common/revision/delta/CDORevisionDeltaImpl.java (-1 / +1 lines)
364	}	364	}
365	else	365	else
366	{	366	{
367	addFeatureDelta(new CDOSetFeatureDeltaImpl(feature, 0, dirtyValue));	367	addFeatureDelta(new CDOSetFeatureDeltaImpl(feature, 0, dirtyValue, originValue));
368	}	368	}
369	}	369	}
370	}	370	}

Lines 23-28 Link Here

(-)src/org/eclipse/emf/cdo/internal/common/revision/delta/CDOSetFeatureDeltaImpl.java (-1 / +31 lines)
23	import org.eclipse.emf.ecore.EStructuralFeature;	23	import org.eclipse.emf.ecore.EStructuralFeature;
24		24
25	import java.io.IOException;	25	import java.io.IOException;
		26	import java.text.MessageFormat;
26		27
27	/**	28	/**
28	* @author Simon McDuff	29	* @author Simon McDuff
Lines 30-40 Link Here
30	public class CDOSetFeatureDeltaImpl extends CDOSingleValueFeatureDeltaImpl implements CDOSetFeatureDelta,	31	public class CDOSetFeatureDeltaImpl extends CDOSingleValueFeatureDeltaImpl implements CDOSetFeatureDelta,
31	ListTargetAdding	32	ListTargetAdding
32	{	33	{
		34	private Object oldValue = CDOSetFeatureDelta.UNSPECIFIED;
		35
33	public CDOSetFeatureDeltaImpl(EStructuralFeature feature, int index, Object value)	36	public CDOSetFeatureDeltaImpl(EStructuralFeature feature, int index, Object value)
34	{	37	{
35	super(feature, index, value);	38	super(feature, index, value);
36	}	39	}
37		40
		41	public CDOSetFeatureDeltaImpl(EStructuralFeature feature, int index, Object value, Object oldValue)
		42	{
		43	super(feature, index, value);
		44	this.oldValue = oldValue;
		45	}
		46
38	public CDOSetFeatureDeltaImpl(CDODataInput in, EClass eClass) throws IOException	47	public CDOSetFeatureDeltaImpl(CDODataInput in, EClass eClass) throws IOException
39	{	48	{
40	super(in, eClass);	49	super(in, eClass);
Lines 47-53 Link Here
47		56
48	public CDOFeatureDelta copy()	57	public CDOFeatureDelta copy()
49	{	58	{
50	return new CDOSetFeatureDeltaImpl(getFeature(), getIndex(), getValue());	59	return new CDOSetFeatureDeltaImpl(getFeature(), getIndex(), getValue(), getOldValue());
51	}	60	}
52		61
53	public void apply(CDORevision revision)	62	public void apply(CDORevision revision)
Lines 59-62 Link Here
59	{	68	{
60	visitor.visit(this);	69	visitor.visit(this);
61	}	70	}
		71
		72	public Object getOldValue()
		73	{
		74	return oldValue;
		75	}
		76
		77	@Override
		78	protected String toStringAdditional()
		79	{
		80	String oldValueForMessage;
		81	if (oldValue != CDOSetFeatureDelta.UNSPECIFIED)
		82	{
		83	oldValueForMessage = oldValue == null ? "null" : oldValue.toString();
		84	}
		85	else
		86	{
		87	oldValueForMessage = "UNSPECIFIED"; //$NON-NLS-1$
		88	}
		89
		90	return super.toStringAdditional() + MessageFormat.format(", oldValue={0}", oldValueForMessage); //$NON-NLS-1$
		91	}
62	}	92	}

Lines 15-20 Link Here

(-)META-INF/MANIFEST.MF (+1 lines)
15	org.eclipse.net4j.db.h2;bundle-version="[4.0.0,5.0.0)";visibility:=reexport,	15	org.eclipse.net4j.db.h2;bundle-version="[4.0.0,5.0.0)";visibility:=reexport,
16	org.eclipse.emf.ecore.xmi;bundle-version="[2.4.0,3.0.0)";visibility:=reexport,	16	org.eclipse.emf.ecore.xmi;bundle-version="[2.4.0,3.0.0)";visibility:=reexport,
17	org.eclipse.emf.edit;bundle-version="[2.4.0,3.0.0)",	17	org.eclipse.emf.edit;bundle-version="[2.4.0,3.0.0)",
		18	org.eclipse.emf.transaction;bundle-version="[1.4.0,1.5.0)",
18	org.eclipse.emf.cdo.common;bundle-version="[4.0.0,5.0.0)";visibility:=reexport,	19	org.eclipse.emf.cdo.common;bundle-version="[4.0.0,5.0.0)";visibility:=reexport,
19	org.eclipse.emf.cdo.common.db;bundle-version="[3.0.0,4.0.0)";visibility:=reexport,	20	org.eclipse.emf.cdo.common.db;bundle-version="[3.0.0,4.0.0)";visibility:=reexport,
20	org.eclipse.emf.cdo;bundle-version="[4.0.0,5.0.0)";visibility:=reexport,	21	org.eclipse.emf.cdo;bundle-version="[4.0.0,5.0.0)";visibility:=reexport,

Lines 136-141 Link Here

(-)src/org/eclipse/emf/cdo/tests/AllConfigs.java (+1 lines)
136	testClasses.add(ChunkingTest.class);	136	testClasses.add(ChunkingTest.class);
137	testClasses.add(ChunkingWithMEMTest.class);	137	testClasses.add(ChunkingWithMEMTest.class);
138	testClasses.add(PackageRegistryTest.class);	138	testClasses.add(PackageRegistryTest.class);
		139	testClasses.add(PartialCommitTest.class);
139	testClasses.add(MetaTest.class);	140	testClasses.add(MetaTest.class);
140	testClasses.add(RevisionDeltaTest.class);	141	testClasses.add(RevisionDeltaTest.class);
141	testClasses.add(RevisionHolderTest.class);	142	testClasses.add(RevisionHolderTest.class);




package org.eclipse.emf.cdo.tests;

import org.eclipse.emf.cdo.CDOObject;
import org.eclipse.emf.cdo.common.id.CDOID;
import org.eclipse.emf.cdo.eresource.CDOResource;
import org.eclipse.emf.cdo.session.CDOSession;
import org.eclipse.emf.cdo.tests.legacy.model1.Model1Package;
import org.eclipse.emf.cdo.tests.legacy.model4.model4Package;
import org.eclipse.emf.cdo.tests.model1.Category;
import org.eclipse.emf.cdo.tests.model1.Company;
import org.eclipse.emf.cdo.tests.model1.Model1Factory;
import org.eclipse.emf.cdo.tests.model1.Product1;
import org.eclipse.emf.cdo.tests.model1.PurchaseOrder;
import org.eclipse.emf.cdo.tests.model1.Supplier;
import org.eclipse.emf.cdo.tests.model4.ContainedElementNoOpposite;
import org.eclipse.emf.cdo.tests.model4.MultiNonContainedElement;
import org.eclipse.emf.cdo.tests.model4.RefMultiNonContained;
import org.eclipse.emf.cdo.tests.model4.RefSingleContainedNPL;
import org.eclipse.emf.cdo.tests.model4.RefSingleNonContained;
import org.eclipse.emf.cdo.tests.model4.SingleNonContainedElement;
import org.eclipse.emf.cdo.tests.model4.model4Factory;
import org.eclipse.emf.cdo.util.CDOUtil;
import org.eclipse.emf.cdo.util.CommitException;
import org.eclipse.emf.cdo.util.CommitIntegrityCheck;
import org.eclipse.emf.cdo.util.CommitIntegrityCheck.Style;
import org.eclipse.emf.cdo.util.CommitIntegrityException;
import org.eclipse.emf.cdo.view.CDOView;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.spi.cdo.InternalCDOTransaction;
import org.eclipse.emf.spi.cdo.InternalCDOTransaction.InternalCDOCommitContext;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class PartialCommitTest extends AbstractCDOTest
{
  private static String RESOURCENAME = "/r1";

  private CDOSession session;

  private InternalCDOTransaction tx;

  private CDOResource resource1;

  /* ---- Model 1 stuff ---- */

  private Company company1, company2, company3, company99;

  private PurchaseOrder purchaseOrder;

  private Supplier supplier1;

  /* ---- Model 4 stuff ---- */

  private RefSingleContainedNPL refSingleContained1, refSingleContained2;

  private ContainedElementNoOpposite singleContainedElement1;

  private RefSingleNonContained refSingleNonContained1, refSingleNonContained2;

  private SingleNonContainedElement singleNonContainedElement1, singleNonContainedElement2;

  private RefMultiNonContained refMultiNonContained1, refMultiNonContained2;

  private MultiNonContainedElement multiNonContainedElement1, multiNonContainedElement2;

  @Override
  public void setUp() throws Exception
  {
    super.setUp();
    session = openSession();
    session.options().setPassiveUpdateEnabled(false);
    tx = (InternalCDOTransaction)session.openTransaction();
  }

  @Override
  public void tearDown() throws Exception
  {
    tx.close();
    session.close();
    super.tearDown();
  }

  public void testNewTopLevelResource() throws CommitException
  {
    CDOResource topResource1 = tx.createResource("/top1");
    tx.commit();

    topResource1.setName("top1_newname"); // Make dirty but don't include; this causes partial commit
    CDOResource topResource2 = tx.createResource("/top2");
    tx.setCommittables(createSet(topResource2, tx.getRootResource()));
    goodAll();
  }

  public void testNewTopLevelResource_rootResourceNotIncluded() throws CommitException
  {
    CDOResource topResource1 = tx.createResource("/top1");
    tx.commit();

    topResource1.setName("top1_newname"); // Make dirty but don't include; this causes partial commit
    CDOResource topResource2 = tx.createResource("/top2");
    tx.setCommittables(createSet(topResource2));
    badAll(createSet(tx.getRootResource()));
  }

  public void testNewNestedResource() throws CommitException
  {
    CDOResource topResource1 = tx.createResource("/top1");
    tx.commit();

    topResource1.setName("top1_newname"); // Make dirty but don't include; this causes partial commit
    CDOResource nestedResource = tx.createResource("/folder/nested");
    tx.setCommittables(createSet(nestedResource, nestedResource.getFolder(), tx.getRootResource()));
    goodAll();
  }

  public void testNewNestedResource_rootResourceNotIncluded() throws CommitException
  {
    CDOResource topResource1 = tx.createResource("/top1");
    tx.commit();

    topResource1.setName("top1_newname"); // Make dirty but don't include; this causes partial commit
    CDOResource nestedResource = tx.createResource("/folder/nested");
    tx.setCommittables(createSet(nestedResource, nestedResource.getFolder()));
    badAll(createSet(tx.getRootResource()));
  }

  public void testNewNestedResource_resourceFolderNotIncluded() throws CommitException
  {
    CDOResource topResource1 = tx.createResource("/top1");
    tx.commit();

    topResource1.setName("top1_newname"); // Make dirty but don't include; this causes partial commit
    CDOResource nestedResource = tx.createResource("/folder/nested");
    tx.setCommittables(createSet(nestedResource, tx.getRootResource()));
    badAll(createSet(nestedResource.getFolder()));
  }

  public void testPartialCleanUp_dirtyObjects() throws CommitException
  {
    simpleModel1Setup();

    company1.setName("Company1");
    company2.setName("Company2");
    company3.setName("Company3");

    tx.setCommittables(createSet(company1));
    tx.commit();

    assertClean(company1, tx);
    assertDirty(company2, tx);
    assertDirty(company3, tx);
    assertTrue(tx.isDirty());

    tx.setCommittables(createSet(company2));
    tx.commit();

    assertClean(company1, tx);
    assertClean(company2, tx);
    assertDirty(company3, tx);
    assertTrue(tx.isDirty());

    tx.setCommittables(createSet(company3));
    tx.commit();

    assertClean(company1, tx);
    assertClean(company2, tx);
    assertClean(company3, tx);
    assertFalse(tx.isDirty());
  }

  public void testPartialCleanUp_newObjects() throws CommitException
  {
    simpleModel1Setup();
    Category cat = Model1Factory.eINSTANCE.createCategory();
    resource1.getContents().add(cat);
    tx.commit();

    company1.setName("Zzz"); // Make dirty but don't include; so as to force partial commit

    // Make some new objects; but with different containers
    Company company4 = Model1Factory.eINSTANCE.createCompany();
    resource1.getContents().add(company4);
    PurchaseOrder po = Model1Factory.eINSTANCE.createPurchaseOrder();
    company2.getPurchaseOrders().add(po);
    Product1 product = Model1Factory.eINSTANCE.createProduct1();
    cat.getProducts().add(product);

    tx.setCommittables(createSet(company4, resource1));
    tx.commit();

    assertClean(company4, tx);
    assertNew(po, tx);
    assertNew(product, tx);
    assertTrue(tx.isDirty());

    tx.setCommittables(createSet(po, company2));
    tx.commit();

    assertClean(company4, tx);
    assertClean(po, tx);
    assertNew(product, tx);
    assertTrue(tx.isDirty());

    tx.setCommittables(createSet(product, cat));
    tx.commit();

    assertClean(company4, tx);
    assertClean(po, tx);
    assertClean(product, tx);
    assertTrue(tx.isDirty());

    tx.setCommittables(createSet(company1));
    tx.commit();
    assertFalse(tx.isDirty());
  }

  public void testPartialCleanUp_detachedObjects() throws CommitException
  {
    simpleModel1Setup();
    Category cat = Model1Factory.eINSTANCE.createCategory();
    resource1.getContents().add(cat);

    // Make some new objects; but with different containers
    Company company4 = Model1Factory.eINSTANCE.createCompany();
    resource1.getContents().add(company4);
    PurchaseOrder po = Model1Factory.eINSTANCE.createPurchaseOrder();
    company2.getPurchaseOrders().add(po);
    Product1 product = Model1Factory.eINSTANCE.createProduct1();
    cat.getProducts().add(product);
    tx.commit();

    company1.setName("Zzz"); // Make dirty but don't include; so as to force partial commit

    resource1.getContents().remove(company4);
    company2.getPurchaseOrders().remove(po);
    cat.getProducts().remove(product);

    assertTrue(tx.getDetachedObjects().containsValue(company4));
    assertTrue(tx.getFormerRevisionKeys().containsKey(company4));
    assertTrue(tx.getDetachedObjects().containsValue(po));
    assertTrue(tx.getFormerRevisionKeys().containsKey(company4));
    assertTrue(tx.getDetachedObjects().containsValue(product));
    assertTrue(tx.getFormerRevisionKeys().containsKey(company4));
    assertTrue(tx.isDirty());

    tx.setCommittables(createSet(company4, resource1));
    tx.commit();

    assertFalse(tx.getDetachedObjects().containsValue(company4));
    assertFalse(tx.getFormerRevisionKeys().containsKey(company4));
    assertTrue(tx.getDetachedObjects().containsValue(po));
    assertTrue(tx.getFormerRevisionKeys().containsKey(po));
    assertTrue(tx.getDetachedObjects().containsValue(product));
    assertTrue(tx.getFormerRevisionKeys().containsKey(product));
    assertTrue(tx.isDirty());

    tx.setCommittables(createSet(po, company2));
    tx.commit();

    assertFalse(tx.getDetachedObjects().containsValue(company4));
    assertFalse(tx.getFormerRevisionKeys().containsKey(company4));
    assertFalse(tx.getDetachedObjects().containsValue(po));
    assertFalse(tx.getFormerRevisionKeys().containsKey(po));
    assertTrue(tx.getDetachedObjects().containsValue(product));
    assertTrue(tx.getFormerRevisionKeys().containsKey(product));
    assertTrue(tx.isDirty());

    tx.setCommittables(createSet(product, cat));
    tx.commit();

    assertFalse(tx.getDetachedObjects().containsValue(company4));
    assertFalse(tx.getFormerRevisionKeys().containsKey(company4));
    assertFalse(tx.getDetachedObjects().containsValue(po));
    assertFalse(tx.getFormerRevisionKeys().containsKey(po));
    assertFalse(tx.getDetachedObjects().containsValue(product));
    assertFalse(tx.getFormerRevisionKeys().containsKey(product));
    assertTrue(tx.isDirty());

    tx.setCommittables(createSet(company1));
    tx.commit();
    assertFalse(tx.isDirty());
  }

  public void testDirty() throws CommitException
  {
    simpleModel1Setup();
    supplier1.setName("Supplier");
    company1.setName("Company");

    tx.setCommittables(createSet(supplier1));
    tx.commit();

    assertDirty(company1, tx);
    assertEquals(company1.getName(), "Company");

    assertClean(supplier1, tx);
    assertEquals(supplier1.getName(), "Supplier");
  }

  public void testNew() throws CommitException
  {
    simpleModel1Setup();
    PurchaseOrder po = Model1Factory.eINSTANCE.createPurchaseOrder();
    company2.getPurchaseOrders().add(po);

    // Include both the new object and its container
    tx.setCommittables(createSet(company2, po));
    goodAll();
  }

  public void testNew_containerOfNewObjectNotIncluded() throws CommitException
  {
    simpleModel1Setup();
    PurchaseOrder po = Model1Factory.eINSTANCE.createPurchaseOrder();
    company2.getPurchaseOrders().add(po);

    // Include only the new object
    tx.setCommittables(createSet(po));
    badAll(createSet(company2));
  }

  public void testNew_newObjectNotIncluded() throws CommitException
  {
    simpleModel1Setup();
    PurchaseOrder po = Model1Factory.eINSTANCE.createPurchaseOrder();
    company2.getPurchaseOrders().add(po);

    // Include only the new object's container
    tx.setCommittables(createSet(company2));
    badAll(createSet(po));
  }

  public void testDetach() throws CommitException
  {
    simpleModel1Setup();
    EcoreUtil.delete(purchaseOrder);

    // Include the detached object and its old container
    tx.setCommittables(createSet(company1, purchaseOrder));
    goodAll();
  }

  public void testDetach_containerOfDetachedObjectNotIncluded() throws CommitException
  {
    simpleModel1Setup();
    EcoreUtil.delete(purchaseOrder);

    // Include only the detached object
    tx.setCommittables(createSet(purchaseOrder));
    badAll(createSet(company1));
  }

  public void testDetach_detachedObjectNotIncluded() throws CommitException
  {
    simpleModel1Setup();
    EcoreUtil.delete(purchaseOrder);

    // Include only the detached object's old container
    tx.setCommittables(createSet(company1));
    badAll(createSet(purchaseOrder));
  }

  public void testMove() throws CommitException
  {
    simpleModel1Setup();
    company2.getPurchaseOrders().add(purchaseOrder);
    supplier1.setName("Supplier");

    // Include the old and new containers as well as the object that was moved
    tx.setCommittables(createSet(purchaseOrder, company1, company2));
    goodAll();

    assertClean(company1, tx);
    assertClean(company2, tx);
    assertClean(purchaseOrder, tx);
    assertDirty(supplier1, tx);

    assertFalse(company1.getPurchaseOrders().contains(purchaseOrder));
    assertTrue(company2.getPurchaseOrders().contains(purchaseOrder));
    assertEquals("Supplier", supplier1.getName());
    assertSame(company2, purchaseOrder.eContainer());
  }

  public void testMove_newContainerNotIncluded() throws CommitException
  {
    simpleModel1Setup();
    company2.getPurchaseOrders().add(purchaseOrder);

    // Include only the object that was moved and its old container
    tx.setCommittables(createSet(purchaseOrder, company1));
    badAll(createSet(company2));
  }

  public void testMove_oldContainerNotIncluded() throws CommitException
  {
    simpleModel1Setup();
    company2.getPurchaseOrders().add(purchaseOrder);

    // Include only the object that was moved and its new container
    tx.setCommittables(createSet(purchaseOrder, company2));
    badAll(createSet(company1));
  }

  public void testMove_movedObjectNotIncluded() throws CommitException
  {
    simpleModel1Setup();
    company2.getPurchaseOrders().add(purchaseOrder);

    // Include only the old and new containers
    tx.setCommittables(createSet(company1, company2));
    badAll(createSet(purchaseOrder));
  }

  public void testMove_onlyOldContainerIncluded() throws CommitException
  {
    simpleModel1Setup();
    company2.getPurchaseOrders().add(purchaseOrder);

    // Include only the old container
    tx.setCommittables(createSet(company1));
    badAll(createSet(company2, purchaseOrder));
  }

  public void testMove_onlyNewContainerIncluded() throws CommitException
  {
    simpleModel1Setup();
    company2.getPurchaseOrders().add(purchaseOrder);

    // Include only the new container
    tx.setCommittables(createSet(company2));
    badAll(createSet(company1, purchaseOrder));
  }

  public void testMove_onlyMovedObjectIncluded() throws CommitException
  {
    simpleModel1Setup();
    company2.getPurchaseOrders().add(purchaseOrder);

    // Include only the moved object
    tx.setCommittables(createSet(purchaseOrder));
    badAll(createSet(company1, company2));
  }

  public void testDoubleMove() throws CommitException
  {
    simpleModel1Setup();
    company2.getPurchaseOrders().add(purchaseOrder);
    company3.getPurchaseOrders().add(purchaseOrder);

    // Include the old and new containers as well as the object that was moved
    // (The point here is that company2 does NOT have to be included.)
    tx.setCommittables(createSet(purchaseOrder, company1, company3));
    System.out.printf("---> purchaseOrder=%s company1=%s company2=%s company3=%s\n", purchaseOrder, company1, company2,
        company3);
    goodAll();
  }

  public void test_noCommittablesAfterCommit() throws CommitException
  {
    simpleModel1Setup();
    company1.setName("zzz");
    tx.setCommittables(createSet(company1));
    tx.commit();

    assertNull(tx.getCommittables());
  }

  public void testNewSingle() throws CommitException
  {
    simpleModel4ContainmentSetup();
    ContainedElementNoOpposite singleContainedElement = model4Factory.eINSTANCE.createContainedElementNoOpposite();
    refSingleContained2.setElement(singleContainedElement);

    // Include both the new object and its container
    tx.setCommittables(createSet(refSingleContained2, singleContainedElement));
    goodAll();
  }

  public void testNewSingle_containerOfNewObjectNotIncluded() throws CommitException
  {
    simpleModel4ContainmentSetup();
    ContainedElementNoOpposite singleContainedElement = model4Factory.eINSTANCE.createContainedElementNoOpposite();
    refSingleContained2.setElement(singleContainedElement);

    // Include only the new object
    tx.setCommittables(createSet(singleContainedElement));
    badAll(createSet(refSingleContained2));
  }

  public void testNewSingle_newObjectNotIncluded() throws CommitException
  {
    simpleModel4ContainmentSetup();
    ContainedElementNoOpposite singleContainedElement = model4Factory.eINSTANCE.createContainedElementNoOpposite();
    refSingleContained2.setElement(singleContainedElement);

    // Include only the new object's container
    tx.setCommittables(createSet(refSingleContained2));
    badAll(createSet(singleContainedElement));
  }

  public void testDetachSingleRef() throws CommitException
  {
    simpleModel4ContainmentSetup();
    refSingleContained1.setElement(null);

    // Include the detached object and its old container
    tx.setCommittables(createSet(refSingleContained1, singleContainedElement1));
    goodAll();
  }

  public void testDetachSingleRef_containerOfDetachedObjectNotIncluded() throws CommitException
  {
    simpleModel4ContainmentSetup();
    refSingleContained1.setElement(null);

    // Include only the detached object
    tx.setCommittables(createSet(singleContainedElement1));
    badAll(createSet(refSingleContained1));
  }

  public void testDetachSingleRef_detachedObjectNotIncluded() throws CommitException
  {
    simpleModel4ContainmentSetup();
    refSingleContained1.setElement(null);

    // Include only the detached object's old container
    tx.setCommittables(createSet(refSingleContained1));
    badAll(createSet(singleContainedElement1));
  }

  public void testMoveSingleRef() throws CommitException
  {
    simpleModel4ContainmentSetup();
    refSingleContained2.setElement(singleContainedElement1);

    // Include the old and new containers as well as the object that was moved
    tx.setCommittables(createSet(refSingleContained1, refSingleContained2, singleContainedElement1));
    goodAll();
  }

  public void testMoveSingleRef_newContainerNotIncluded() throws CommitException
  {
    simpleModel4ContainmentSetup();
    refSingleContained2.setElement(singleContainedElement1);

    // Include only the object that was moved and its old container
    tx.setCommittables(createSet(refSingleContained1, singleContainedElement1));
    badAll(createSet(refSingleContained2));
  }

  public void testMoveSingleRef_oldContainerNotIncluded() throws CommitException
  {
    simpleModel4ContainmentSetup();
    refSingleContained2.setElement(singleContainedElement1);

    // Include only the object that was moved and its new container
    tx.setCommittables(createSet(refSingleContained2, singleContainedElement1));
    badAll(createSet(refSingleContained1));
  }

  public void testMoveSingleRef_movedObjectNotIncluded() throws CommitException
  {
    simpleModel4ContainmentSetup();
    refSingleContained2.setElement(singleContainedElement1);

    // Include only the old and new containers
    tx.setCommittables(createSet(refSingleContained1, refSingleContained2));
    badAll(createSet(singleContainedElement1));
  }

  public void testMoveSingleRef_onlyOldContainerIncluded() throws CommitException
  {
    simpleModel4ContainmentSetup();
    refSingleContained2.setElement(singleContainedElement1);

    // Include only the old container
    tx.setCommittables(createSet(refSingleContained1));
    badAll(createSet(singleContainedElement1, refSingleContained2));
  }

  public void testMoveSingleRef_onlyNewContainerIncluded() throws CommitException
  {
    simpleModel4ContainmentSetup();
    refSingleContained2.setElement(singleContainedElement1);

    // Include only the new container
    tx.setCommittables(createSet(refSingleContained2));
    badAll(createSet(singleContainedElement1, refSingleContained1));
  }

  public void testMoveSingleRef_onlyMovedObjectIncluded() throws CommitException
  {
    simpleModel4ContainmentSetup();
    refSingleContained2.setElement(singleContainedElement1);

    // Include only the moved object
    tx.setCommittables(createSet(singleContainedElement1));
    badAll(createSet(refSingleContained1, refSingleContained2));
  }

  public void testNewTopLevel() throws CommitException
  {
    simpleModel1Setup();
    Company company = Model1Factory.eINSTANCE.createCompany();
    resource1.getContents().add(company);

    // Include both the resource and the new object
    tx.setCommittables(createSet(resource1, company));
    goodAll();
  }

  public void testNewTopLevel_newObjectNotIncluded() throws CommitException
  {
    simpleModel1Setup();
    Company company = Model1Factory.eINSTANCE.createCompany();
    resource1.getContents().add(company);

    // Include only the resource
    tx.setCommittables(createSet(resource1));
    badAll(createSet(company));
  }

  public void testNewTopLevel_resourceNotIncluded() throws CommitException
  {
    simpleModel1Setup();
    Company company = Model1Factory.eINSTANCE.createCompany();
    resource1.getContents().add(company);

    // Include only the new object
    tx.setCommittables(createSet(company));
    badAll(createSet(resource1));
  }

  public void _testNewTopLevel_resourceNotIncluded() throws CommitException
  {
    simpleModel1Setup();

    CDOID companyID = null;
    {
      Company company = Model1Factory.eINSTANCE.createCompany();
      resource1.getContents().add(company);

      // Include only the new object
      tx.setCommittables(createSet(company));
      tx.commit();

      companyID = CDOUtil.getCDOObject(company).cdoID();
    }

    System.out.println("---> companyID = " + companyID);
    System.out.println("---> " + CDOUtil.getCDOObject(resource1).cdoState());

    {
      CDOSession session2 = openSession();
      CDOView view = session2.openView();
      CDOResource resource = view.getResource(resource1.getPath());

      // We want to know if the new company that was committed, is an element
      // in the getContents() collection of the Resource. We cannot just call
      // getContents().contains(), because of the odd implementation of
      // CDOResourceImpl.contains: it actually asks the element, rather than
      // checking its own collection. So, we have to do this the hard way:
      //
      boolean found = false;
      Iterator<EObject> iter = resource.getContents().iterator();
      while (!found && iter.hasNext())
      {
        CDOObject o = CDOUtil.getCDOObject(iter.next());
        if (o.cdoID().equals(companyID))
        {
          found = true;
        }
      }
      assertTrue(found);

      view.close();
      session2.close();
    }
  }

  // -------- Tests concerning bi-di references ----------
  //
  // Cases to test:
  // Bi-di refs are analogous to containment, the only difference being that
  // bi-di refs are symmetrical, whereas containment/container is not.
  //
  // So:
  //
  // For DIRTY objects, the cases are:
  // 1. Setting a bidi ref to null where it was previously non-null
  // Must check that object owning opposite feature is included
  // 2. Setting a bidi ref to non-null where it was previously null
  // Must check that object owning opposite feature is included
  // 3. Changing a bidi ref from one non-null value to another
  // Must check that both the object owning the NEW opposite feature,
  // as well as the OLD one, are included
  //
  // For NEW objects, the
  // If the detached object had any non-null bidi refs, we must check
  // whether the bidi target is included.
  //
  // For DETACHED objects:
  // If the detached object had any non-null bidi refs, we must check
  // whether the bidi target is included.

  public void testDirtySingleBidiNew() throws CommitException
  {
    simpleModel4SingleBidiSetup();
    singleNonContainedElement2.setParent(refSingleNonContained2);

    tx.setCommittables(createSet(singleNonContainedElement2, refSingleNonContained2));
    goodAll();
  }

  public void testDirtySingleBidiNew_newtargetNotIncluded() throws CommitException
  {
    simpleModel4SingleBidiSetup();
    singleNonContainedElement2.setParent(refSingleNonContained2);

    tx.setCommittables(createSet(singleNonContainedElement2));
    badAll(createSet(refSingleNonContained2));
  }

  public void testDirtySingleBidiChanged() throws CommitException
  {
    simpleModel4SingleBidiSetup();
    // We "reparent" the singleNonContainedElement1
    singleNonContainedElement1.setParent(refSingleNonContained2);

    tx.setCommittables(createSet(singleNonContainedElement1, refSingleNonContained1, refSingleNonContained2));
    goodAll();
  }

  public void testDirtySingleBidiChanged_newTargetNotIncluded() throws CommitException
  {
    simpleModel4SingleBidiSetup();
    // We "reparent" the singleNonContainedElement1
    singleNonContainedElement1.setParent(refSingleNonContained2);

    tx.setCommittables(createSet(singleNonContainedElement1, refSingleNonContained1));
    badAll(createSet(refSingleNonContained2));
  }

  public void testDirtySingleBidiChanged_oldTargetNotIncluded() throws CommitException
  {
    simpleModel4SingleBidiSetup();
    // We "reparent" the singleNonContainedElement1
    singleNonContainedElement1.setParent(refSingleNonContained2);

    tx.setCommittables(createSet(singleNonContainedElement1, refSingleNonContained2));
    badAll(createSet(refSingleNonContained1));
  }

  public void testDirtySingleBidiRemoved() throws CommitException
  {
    simpleModel4SingleBidiSetup();
    singleNonContainedElement1.setParent(null);

    tx.setCommittables(createSet(singleNonContainedElement1, refSingleNonContained1));
    goodAll();
  }

  public void testDirtySingleBidiRemoved_oldTargetNotIncluded() throws CommitException
  {
    simpleModel4SingleBidiSetup();
    singleNonContainedElement1.setParent(null);

    tx.setCommittables(createSet(singleNonContainedElement1));
    badAll(createSet(refSingleNonContained1));
  }

  public void testSingleBidiOnNewObject() throws CommitException
  {
    simpleModel4SingleBidiSetup();
    SingleNonContainedElement newNonContainedElement = model4Factory.eINSTANCE.createSingleNonContainedElement();
    resource1.getContents().add(newNonContainedElement);
    newNonContainedElement.setParent(refSingleNonContained2);

    tx.setCommittables(createSet(newNonContainedElement, resource1, refSingleNonContained2));
    goodAll();
  }

  public void testSingleBidiOnNewObject_targetNotIncluded() throws CommitException
  {
    simpleModel4SingleBidiSetup();
    SingleNonContainedElement newNonContainedElement = model4Factory.eINSTANCE.createSingleNonContainedElement();
    resource1.getContents().add(newNonContainedElement);
    newNonContainedElement.setParent(refSingleNonContained2);

    tx.setCommittables(createSet(newNonContainedElement, resource1));
    badAll(createSet(refSingleNonContained2));
  }

  public void testSingleBidiOnRemovedObject() throws CommitException
  {
    simpleModel4SingleBidiSetup();
    EcoreUtil.delete(singleNonContainedElement1);

    tx.setCommittables(createSet(singleNonContainedElement1, resource1, refSingleNonContained1));
    goodAll();
  }

  public void testSingleBidiOnRemovedObject_targetNotIncluded() throws CommitException
  {
    simpleModel4SingleBidiSetup();
    EcoreUtil.delete(singleNonContainedElement1);

    tx.setCommittables(createSet(singleNonContainedElement1, resource1));
    badAll(createSet(refSingleNonContained1));
  }

  public void testDirtyMultiBidiNew() throws CommitException
  {
    simpleModel4MultiBidiSetup();
    multiNonContainedElement2.setParent(refMultiNonContained2);

    tx.setCommittables(createSet(multiNonContainedElement2, refMultiNonContained2));
    goodAll();
  }

  public void testDirtyMultiBidiNew_newtargetNotIncluded() throws CommitException
  {
    simpleModel4MultiBidiSetup();
    multiNonContainedElement2.setParent(refMultiNonContained2);

    tx.setCommittables(createSet(multiNonContainedElement2));
    badAll(createSet(refMultiNonContained2));
  }

  public void testDirtyMultiBidiChanged() throws CommitException
  {
    simpleModel4MultiBidiSetup();
    // We "reparent" the multiNonContainedElement1
    multiNonContainedElement1.setParent(refMultiNonContained2);

    tx.setCommittables(createSet(multiNonContainedElement1, refMultiNonContained1, refMultiNonContained2));
    goodAll();
  }

  public void testDirtyMultiBidiChanged_newTargetNotIncluded() throws CommitException
  {
    simpleModel4MultiBidiSetup();
    // We "reparent" the multiNonContainedElement1
    multiNonContainedElement1.setParent(refMultiNonContained2);

    tx.setCommittables(createSet(multiNonContainedElement1, refMultiNonContained1));
    badAll(createSet(refMultiNonContained2));
  }

  public void testDirtyMultiBidiChanged_oldTargetNotIncluded() throws CommitException
  {
    simpleModel4MultiBidiSetup();
    // We "reparent" the multiNonContainedElement1
    multiNonContainedElement1.setParent(refMultiNonContained2);

    tx.setCommittables(createSet(multiNonContainedElement1, refMultiNonContained2));
    badAll(createSet(refMultiNonContained1));
  }

  public void testDirtyMultiBidiRemoved() throws CommitException
  {
    simpleModel4MultiBidiSetup();
    multiNonContainedElement1.setParent(null);

    tx.setCommittables(createSet(multiNonContainedElement1, refMultiNonContained1));
    goodAll();
  }

  public void testDirtyMultiBidiRemoved_oldTargetNotIncluded() throws CommitException
  {
    simpleModel4MultiBidiSetup();
    multiNonContainedElement1.setParent(null);

    tx.setCommittables(createSet(multiNonContainedElement1));
    badAll(createSet(refMultiNonContained1));
  }

  public void testMultiBidiOnNewObject() throws CommitException
  {
    simpleModel4MultiBidiSetup();
    MultiNonContainedElement newNonContainedElement = model4Factory.eINSTANCE.createMultiNonContainedElement();
    resource1.getContents().add(newNonContainedElement);
    newNonContainedElement.setParent(refMultiNonContained2);

    tx.setCommittables(createSet(newNonContainedElement, resource1, refMultiNonContained2));
    goodAll();
  }

  public void testMultiBidiOnNewObject_targetNotIncluded() throws CommitException
  {
    simpleModel4MultiBidiSetup();
    MultiNonContainedElement newNonContainedElement = model4Factory.eINSTANCE.createMultiNonContainedElement();
    resource1.getContents().add(newNonContainedElement);
    newNonContainedElement.setParent(refMultiNonContained2);

    tx.setCommittables(createSet(newNonContainedElement, resource1));
    badAll(createSet(refMultiNonContained2));
  }

  public void testMultiBidiOnRemovedObject() throws CommitException
  {
    simpleModel4MultiBidiSetup();
    EcoreUtil.delete(multiNonContainedElement1);

    tx.setCommittables(createSet(multiNonContainedElement1, resource1, refMultiNonContained1));
    goodAll();
  }

  public void testMultiBidiOnRemovedObject_targetNotIncluded() throws CommitException
  {
    simpleModel4MultiBidiSetup();
    EcoreUtil.delete(multiNonContainedElement1);

    tx.setCommittables(createSet(multiNonContainedElement1, resource1));
    badAll(createSet(refMultiNonContained1));
  }

  public void testCheckWithoutCommit_exceptionFast() throws CommitException
  {
    simpleModel1Setup();
    PurchaseOrder po = Model1Factory.eINSTANCE.createPurchaseOrder();
    company2.getPurchaseOrders().add(po);

    // Include only the new object
    tx.setCommittables(createSet(po));
    InternalCDOCommitContext ctx = tx.createCommitContext();
    try
    {
      new CommitIntegrityCheck(ctx, CommitIntegrityCheck.Style.EXCEPTION_FAST).check();
    }
    catch (CommitIntegrityException e)
    {
      // Good
    }
  }

  public void testCheckWithoutCommit_exception() throws CommitException
  {
    simpleModel1Setup();
    PurchaseOrder po = Model1Factory.eINSTANCE.createPurchaseOrder();
    company2.getPurchaseOrders().add(po);

    // Include only the new object
    tx.setCommittables(createSet(po));
    InternalCDOCommitContext ctx = tx.createCommitContext();
    try
    {
      new CommitIntegrityCheck(ctx, CommitIntegrityCheck.Style.EXCEPTION_FAST).check();
    }
    catch (CommitIntegrityException e)
    {
      // Good
    }
  }

  public void testCommittablesContainUncommittableObjects()
  {
    // Idea here is to include some objects in the committables, that exist, but
    // are neither dirty nor detached nor new.
    //
    // Actually, one could wonder what the desirable behavior is in this case.
    // Should there be a failure? Or should the "committables" be considered more like
    // a filter; i.e. it's ok for the filter to cover more than what can actually be committed.
    // Hmm... *ponder* *ponder*.
    //
  }

  /**
   * Test the commit integrity, assuming that it is good, using all possible checking styles.
   */
  private void goodAll() throws CommitException
  {
    good(Style.NO_EXCEPTION);
    good(Style.EXCEPTION_FAST);
    good(Style.EXCEPTION);
    good(null);
  }

  /**
   * Test the commit integrity, assuming that it is good.
   * 
   * @param style
   *          - the checking style to be used; if null, just commit. In that case, the commit logic will choose the
   *          checking style.
   */
  private void good(Style style) throws CommitException
  {
    if (style != null)
    {
      InternalCDOCommitContext ctx = tx.createCommitContext();
      CommitIntegrityCheck check = new CommitIntegrityCheck(ctx, style);

      try
      {
        check.check();
        assertTrue("check.getMissingObjects() should have been empty", check.getMissingObjects().isEmpty());
      }
      catch (CommitIntegrityException e)
      {
        fail("Should not have thrown " + CommitIntegrityException.class.getName());
      }
    }
    else
    {
      try
      {
        // We always make company99 dirty if it's present
        // (This is just a control object to verify that some stuff does NOT get
        // committed.)
        if (company99 != null)
        {
          company99.setName("000");
        }

        tx.commit();

        // And we verify that it didn't get included in the commit
        if (company99 != null)
        {
          assertDirty(company99, tx);
          assertTrue("Transaction should still have been dirty", tx.isDirty());
        }
      }
      catch (CommitException e)
      {
        Throwable cause = e.getCause().getCause();
        if (cause instanceof CommitIntegrityException)
        {
          fail("---> Should not have failed with: " + e.getCause().getMessage());
        }
        else
        {
          throw e;
        }
      }
    }
  }

  /**
   * Test the commit integrity, assuming that it is bad, using all possible checking styles.
   */
  private void badAll(Set<EObject> expectedMissingObjects) throws CommitException
  {
    bad(Style.NO_EXCEPTION, expectedMissingObjects);
    bad(Style.EXCEPTION_FAST, expectedMissingObjects);
    bad(Style.EXCEPTION, expectedMissingObjects);
    bad(null, expectedMissingObjects);
  }

  /**
   * Test the commit integrity, assuming that it is bad.
   * 
   * @param style
   *          - the checking style to be used; if null, just commit. In that case, the commit logic will choose the
   *          checking style.
   */
  private void bad(Style style, Set<EObject> expectedMissingObjects) throws CommitException
  {
    CommitIntegrityException commitIntegrityEx = null;
    Set<? extends EObject> missingObjects = null;

    CommitIntegrityCheck check = null;
    if (style != null)
    {
      InternalCDOCommitContext ctx = tx.createCommitContext();
      check = new CommitIntegrityCheck(ctx, style);
    }

    if (style == Style.NO_EXCEPTION)
    {
      try
      {
        check.check();
      }
      catch (CommitIntegrityException e)
      {
        fail("Should not have thrown " + CommitIntegrityException.class.getName());
      }
    }
    else if (style == CommitIntegrityCheck.Style.EXCEPTION || style == CommitIntegrityCheck.Style.EXCEPTION_FAST)
    {
      try
      {
        check.check();
        fail("Should have thrown " + CommitIntegrityException.class.getName());
      }
      catch (CommitIntegrityException e)
      {
        commitIntegrityEx = e;
      }
    }
    else if (style == null)
    {
      try
      {
        tx.commit();
        fail("Should have thrown " + CommitException.class.getName());
      }
      catch (CommitException e)
      {
        Throwable cause = e.getCause().getCause();
        if (cause instanceof CommitIntegrityException)
        {
          // Good
          commitIntegrityEx = (CommitIntegrityException)cause;
          System.out.println("---> Failed properly: " + e.getCause().getMessage());
        }
        else
        {
          throw e;
        }
      }
    }
    else
    {
      fail("Unknown style");
    }

    if (commitIntegrityEx != null)
    {
      missingObjects = commitIntegrityEx.getMissingObjects();
    }
    else
    {
      missingObjects = check.getMissingObjects();
    }

    if (style == Style.EXCEPTION_FAST)
    {
      assertEquals(1, missingObjects.size());
    }
    else
    {
      // We cannot use == here, because it isn't (always) possible for the logic to
      // find all missing objects
      assertTrue(missingObjects.size() <= expectedMissingObjects.size());
    }

    for (EObject missingObject : missingObjects)
    {
      assertTrue(expectedMissingObjects.contains(missingObject));
    }
  }

  private void simpleModel1Setup() throws CommitException
  {
    EReference ref = Model1Package.eINSTANCE.getCompany_PurchaseOrders();
    boolean preconditions = ref.isContainment() && ref.getEOpposite() == null && ref.isMany();
    if (!preconditions)
    {
      throw new RuntimeException("Model1 does not meet prerequirements for this test");
    }

    resource1 = tx.createResource(RESOURCENAME);
    company1 = Model1Factory.eINSTANCE.createCompany();
    company2 = Model1Factory.eINSTANCE.createCompany();
    company3 = Model1Factory.eINSTANCE.createCompany();
    company99 = Model1Factory.eINSTANCE.createCompany();
    supplier1 = Model1Factory.eINSTANCE.createSupplier();
    purchaseOrder = Model1Factory.eINSTANCE.createPurchaseOrder();
    company1.getPurchaseOrders().add(purchaseOrder);
    resource1.getContents().add(company1);
    resource1.getContents().add(company2);
    resource1.getContents().add(company3);
    resource1.getContents().add(company99);
    resource1.getContents().add(supplier1);
    tx.commit();
  }

  private void simpleModel4ContainmentSetup() throws CommitException
  {
    EReference ref = model4Package.eINSTANCE.getRefSingleContainedNPL_Element();
    boolean preconditions = ref.isContainment() && ref.getEOpposite() == null && !ref.isMany();
    if (!preconditions)
    {
      throw new RuntimeException("Model4 does not meet prerequirements for this test");
    }

    resource1 = tx.createResource(RESOURCENAME);

    refSingleContained1 = model4Factory.eINSTANCE.createRefSingleContainedNPL();
    refSingleContained2 = model4Factory.eINSTANCE.createRefSingleContainedNPL();
    singleContainedElement1 = model4Factory.eINSTANCE.createContainedElementNoOpposite();
    refSingleContained1.setElement(singleContainedElement1);
    resource1.getContents().add(refSingleContained1);
    resource1.getContents().add(refSingleContained2);

    tx.commit();
  }

  private void simpleModel4SingleBidiSetup() throws CommitException
  {
    EReference ref = model4Package.eINSTANCE.getRefSingleNonContained_Element();
    boolean preconditions = !ref.isContainment() && ref.getEOpposite() != null && !ref.isMany();
    if (!preconditions)
    {
      throw new RuntimeException("Model4 does not meet prerequirements for this test");
    }

    resource1 = tx.createResource(RESOURCENAME);

    refSingleNonContained1 = model4Factory.eINSTANCE.createRefSingleNonContained();
    refSingleNonContained2 = model4Factory.eINSTANCE.createRefSingleNonContained();
    singleNonContainedElement1 = model4Factory.eINSTANCE.createSingleNonContainedElement();
    singleNonContainedElement2 = model4Factory.eINSTANCE.createSingleNonContainedElement();
    refSingleNonContained1.setElement(singleNonContainedElement1);
    resource1.getContents().add(refSingleNonContained1);
    resource1.getContents().add(refSingleNonContained2);
    resource1.getContents().add(singleNonContainedElement1);
    resource1.getContents().add(singleNonContainedElement2);

    tx.commit();
  }

  private void simpleModel4MultiBidiSetup() throws CommitException
  {
    EReference ref = model4Package.eINSTANCE.getRefMultiNonContained_Elements();
    boolean preconditions = !ref.isContainment() && ref.getEOpposite() != null && ref.isMany();
    if (!preconditions)
    {
      throw new RuntimeException("Model4 does not meet prerequirements for this test");
    }

    resource1 = tx.createResource(RESOURCENAME);

    refMultiNonContained1 = model4Factory.eINSTANCE.createRefMultiNonContained();
    refMultiNonContained2 = model4Factory.eINSTANCE.createRefMultiNonContained();
    multiNonContainedElement1 = model4Factory.eINSTANCE.createMultiNonContainedElement();
    multiNonContainedElement2 = model4Factory.eINSTANCE.createMultiNonContainedElement();
    refMultiNonContained1.getElements().add(multiNonContainedElement1);
    resource1.getContents().add(refMultiNonContained1);
    resource1.getContents().add(refMultiNonContained2);
    resource1.getContents().add(multiNonContainedElement1);
    resource1.getContents().add(multiNonContainedElement2);

    tx.commit();
  }

  private Set<EObject> createSet(EObject... objects)
  {
    Set<EObject> committables = new HashSet<EObject>();
    for (EObject o : objects)
    {
      if (o == null)
      {
        throw new NullPointerException();
      }
      committables.add(o);
    }
    return committables;
  }
}

Return to bug 312535

Lines 597-600 Link Here

(-)src/org/eclipse/emf/cdo/transaction/CDOPushTransaction.java (+16 lines)
597	{	597	{
598	delegate.setCommitComment(comment);	598	delegate.setCommitComment(comment);
599	}	599	}
		600
		601	/**
		602	* @since 4.0
		603	*/
		604	public void setCommittables(Set<EObject> committables)
		605	{
		606	delegate.setCommittables(committables);
		607	}
		608
		609	/**
		610	* @since 4.0
		611	*/
		612	public Set<EObject> getCommittables()
		613	{
		614	return delegate.getCommittables();
		615	}
600	}	616	}

Added Link Here

(-)src/org/eclipse/emf/cdo/util/CommitIntegrityCheck.java (+422 lines)
1	/**
2	* Copyright (c) 2004 - 2010 Eike Stepper (Berlin, Germany) and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Caspar De Groot - initial API and implementation
10	*/
11	package org.eclipse.emf.cdo.util;
12
13	import org.eclipse.emf.cdo.CDOObject;
14	import org.eclipse.emf.cdo.common.id.CDOID;
15	import org.eclipse.emf.cdo.common.id.CDOID.Type;
16	import org.eclipse.emf.cdo.common.revision.delta.CDOAddFeatureDelta;
17	import org.eclipse.emf.cdo.common.revision.delta.CDOClearFeatureDelta;
18	import org.eclipse.emf.cdo.common.revision.delta.CDOContainerFeatureDelta;
19	import org.eclipse.emf.cdo.common.revision.delta.CDOFeatureDelta;
20	import org.eclipse.emf.cdo.common.revision.delta.CDOListFeatureDelta;
21	import org.eclipse.emf.cdo.common.revision.delta.CDORemoveFeatureDelta;
22	import org.eclipse.emf.cdo.common.revision.delta.CDORevisionDelta;
23	import org.eclipse.emf.cdo.common.revision.delta.CDORevisionDeltaUtil;
24	import org.eclipse.emf.cdo.common.revision.delta.CDOSetFeatureDelta;
25	import org.eclipse.emf.cdo.common.revision.delta.CDOUnsetFeatureDelta;
26	import org.eclipse.emf.cdo.eresource.CDOResource;
27	import org.eclipse.emf.cdo.spi.common.revision.InternalCDORevision;
28
29	import org.eclipse.net4j.util.CheckUtil;
30
31	import org.eclipse.emf.common.util.EList;
32	import org.eclipse.emf.ecore.EObject;
33	import org.eclipse.emf.ecore.EReference;
34	import org.eclipse.emf.ecore.EStructuralFeature;
35	import org.eclipse.emf.ecore.InternalEObject.EStore;
36	import org.eclipse.emf.spi.cdo.InternalCDOObject;
37	import org.eclipse.emf.spi.cdo.InternalCDOTransaction;
38	import org.eclipse.emf.spi.cdo.InternalCDOTransaction.InternalCDOCommitContext;
39
40	import java.util.HashSet;
41	import java.util.Set;
42
43	/**
44	* @author Caspar De Groot
45	* @since 4.0
46	*/
47	public class CommitIntegrityCheck
48	{
49	private InternalCDOTransaction transaction;
50
51	private Style style;
52
53	private Set<CDOID> newIDs, dirtyIDs, detachedIDs;
54
55	private Set<CDOObject> missingObjects = new HashSet<CDOObject>();
56
57	private StringBuilder exceptionMessage = new StringBuilder();
58
59	public CommitIntegrityCheck(InternalCDOCommitContext commitContext)
60	{
61	this(commitContext, Style.EXCEPTION_FAST);
62	}
63
64	public CommitIntegrityCheck(InternalCDOCommitContext commitContext, Style style)
65	{
66	transaction = commitContext.getTransaction();
67
68	CheckUtil.checkNull(style, "style should not be null");
69	this.style = style;
70
71	newIDs = commitContext.getNewObjects().keySet();
72	dirtyIDs = commitContext.getDirtyObjects().keySet();
73	detachedIDs = commitContext.getDetachedObjects().keySet();
74	}
75
76	public void check() throws CommitIntegrityException
77	{
78	// For new objects: ensure that their container is included,
79	// as well as the targets of the new object's bidi references
80	for (CDOID newID : newIDs)
81	{
82	CDOObject newObject = transaction.getObject(newID);
83	checkContainerIncluded(newObject, "new");
84	checkCurrentBidiRefTargetsIncluded(newObject, "new");
85	}
86
87	// For detached objects: ensure that their former container is included,
88	// as well as the targets of the detached object's bidi references
89	for (CDOID detachedID : detachedIDs)
90	{
91	CDOObject detachedObject = transaction.getObject(detachedID);
92	checkFormerContainerIncluded(detachedObject);
93	checkFormerBidiRefTargetsIncluded(detachedObject, "detached");
94	}
95
96	// For dirty objects: if any of the deltas for the object, affect containment (i.e. object was moved)
97	// or a bi-di reference, ensure that for containment, both the old and new containers are included,
98	// (or that the child is included if we are considering the dirty parent),
99	// and that for a bi-di reference, the object holding the other end of the bi-di is included, as
100	// well as possibly the former object holding the other end.
101	//
102	for (CDOID dirtyID : dirtyIDs)
103	{
104	CDOObject dirtyObject = transaction.getObject(dirtyID);
105	analyzeRevisionDelta((InternalCDOObject)dirtyObject);
106	}
107
108	if (!missingObjects.isEmpty() && style == Style.EXCEPTION)
109	{
110	throw createException();
111	}
112	}
113
114	public Set<? extends EObject> getMissingObjects()
115	{
116	return missingObjects;
117	}
118
119	private CDOID getContainerOrResourceID(InternalCDORevision revision)
120	{
121	CDOID containerOrResourceID = null;
122	Object idOrObject = revision.getContainerID();
123	if (idOrObject != null)
124	{
125	containerOrResourceID = (CDOID)transaction.convertObjectToID(idOrObject);
126	}
127
128	if (containerOrResourceID == null \|\| containerOrResourceID.getType() == Type.NULL)
129	{
130	idOrObject = revision.getResourceID();
131	if (idOrObject != null)
132	{
133	containerOrResourceID = (CDOID)transaction.convertObjectToID(idOrObject);
134	}
135	}
136
137	return containerOrResourceID;
138	}
139
140	private void analyzeRevisionDelta(InternalCDOObject dirtyObject) throws CommitIntegrityException
141	{
142	// Getting the deltas from the TX is not a good idea...
143	// We better recompute a fresh delta:
144	//
145	InternalCDORevision cleanRev = transaction.getCleanRevisions().get(dirtyObject);
146	CheckUtil.checkNull(cleanRev, "Could not obtain clean revision for dirty object " + dirtyObject);
147	InternalCDORevision dirtyRev = dirtyObject.cdoRevision();
148	CDORevisionDelta rDelta = CDORevisionDeltaUtil.create(cleanRev, dirtyRev);
149
150	for (CDOFeatureDelta featureDelta : rDelta.getFeatureDeltas())
151	{
152	EStructuralFeature feat = featureDelta.getFeature();
153	if (feat == CDOContainerFeatureDelta.CONTAINER_FEATURE)
154	{
155	// Object is dirty with respect to its container; this means it was moved;
156	// We must ensure that both the old and new containers are included
157	checkContainerIncluded(dirtyObject, "moved");
158	CDOID containerOrResourceID = getContainerOrResourceID(cleanRev);
159	checkIncluded(containerOrResourceID, "former container (or resource) of moved", dirtyObject);
160	}
161	else if (feat instanceof EReference)
162	{
163	EReference ref = (EReference)feat;
164	if (ref.isContainment() \|\| ref.getEOpposite() != null)
165	{
166	// Object is dirty with respect to a containment feature
167	// We must ensure that any children that were added/removed, are also
168	// included in the commit
169
170	if (featureDelta instanceof CDOListFeatureDelta)
171	{
172	for (CDOFeatureDelta innerFeatDelta : ((CDOListFeatureDelta)featureDelta).getListChanges())
173	{
174	checkContainmentDelta(innerFeatDelta, dirtyObject);
175	}
176	}
177	else
178	{
179	checkContainmentDelta(featureDelta, dirtyObject);
180	}
181	}
182	}
183	}
184	}
185
186	private void checkContainmentDelta(CDOFeatureDelta featureDelta, CDOObject dirtyObject)
187	throws CommitIntegrityException
188	{
189	if (featureDelta instanceof CDORemoveFeatureDelta)
190	{
191	Object idOrObject = ((CDORemoveFeatureDelta)featureDelta).getValue();
192	CDOID id = (CDOID)transaction.convertObjectToID(idOrObject);
193	checkIncluded(id, "removed child of", dirtyObject);
194	}
195	else if (featureDelta instanceof CDOAddFeatureDelta)
196	{
197	Object idOrObject = ((CDOAddFeatureDelta)featureDelta).getValue();
198	CDOID id = (CDOID)transaction.convertObjectToID(idOrObject);
199	if (id.getType() != CDOID.Type.NULL)
200	{
201	checkIncluded(id, "added child of", dirtyObject);
202	}
203	}
204	else if (featureDelta instanceof CDOSetFeatureDelta)
205	{
206	Object newIDOrObject = ((CDOSetFeatureDelta)featureDelta).getValue();
207	Object oldIDOrObject = ((CDOSetFeatureDelta)featureDelta).getOldValue();
208	CDOID oldID = (CDOID)transaction.convertObjectToID(oldIDOrObject);
209	if (oldIDOrObject != null)
210	{
211	if (newIDOrObject == null)
212	{
213	// Removal: old child must be included
214	checkIncluded(oldID, "removed child of", dirtyObject);
215	}
216	else
217	{
218	// Change: both old and new child must be included
219	checkIncluded(oldID, "former child of", dirtyObject);
220	CDOID newID = (CDOID)transaction.convertObjectToID(newIDOrObject);
221	checkIncluded(newID, "new child of", dirtyObject);
222	}
223	}
224	else
225	{
226	// New child, no old child
227	CDOID newID = (CDOID)transaction.convertObjectToID(newIDOrObject);
228	checkIncluded(newID, "new child of", dirtyObject);
229	}
230	}
231	else if (featureDelta instanceof CDOClearFeatureDelta)
232	{
233	EStructuralFeature feat = ((CDOClearFeatureDelta)featureDelta).getFeature();
234	InternalCDORevision cleanRev = transaction.getCleanRevisions().get(dirtyObject);
235	int n = cleanRev.size(feat);
236	for (int i = 0; i < n; i++)
237	{
238	Object idOrObject = cleanRev.get(feat, i);
239	CDOID id = (CDOID)transaction.convertObjectToID(idOrObject);
240	checkIncluded(id, "removed child of", dirtyObject);
241	}
242	}
243	else if (featureDelta instanceof CDOUnsetFeatureDelta)
244	{
245	EStructuralFeature feat = ((CDOUnsetFeatureDelta)featureDelta).getFeature();
246	InternalCDORevision cleanRev = transaction.getCleanRevisions().get(dirtyObject);
247	Object idOrObject = cleanRev.getValue(feat);
248	CDOID id = (CDOID)transaction.convertObjectToID(idOrObject);
249	checkIncluded(id, "removed child of", dirtyObject);
250	}
251	else
252	{
253	throw new RuntimeException("Unexpected delta type: " + featureDelta.getClass().getSimpleName());
254	}
255	}
256
257	private void checkIncluded(CDOID id, String msg, CDOObject o) throws CommitIntegrityException
258	{
259	if (id.getType() == Type.NULL)
260	{
261	throw new IllegalArgumentException("CDOID must not be of type NULL");
262	}
263
264	if (!dirtyIDs.contains(id) && !detachedIDs.contains(id) && !newIDs.contains(id))
265	{
266	CDOObject missingObject = transaction.getObject(id);
267	if (missingObject == null)
268	{
269	throw new IllegalStateException("Could not find object for CDOID " + id);
270	}
271	missingObjects.add(missingObject);
272
273	if (exceptionMessage.length() > 0)
274	{
275	exceptionMessage.append('\n');
276	}
277	String m = String.format("The %s object %s needs to be included in the commit but isn't", msg, o);
278	exceptionMessage.append(m);
279
280	if (style == Style.EXCEPTION_FAST)
281	{
282	throw createException();
283	}
284	}
285	}
286
287	private CommitIntegrityException createException()
288	{
289	return new CommitIntegrityException(exceptionMessage.toString(), missingObjects);
290	}
291
292	/**
293	* Checks whether the container of a given object is included in the commit
294	*
295	* @param msgFrag
296	* @throws CommitIntegrityException
297	*/
298	private void checkContainerIncluded(CDOObject object, String msgFrag) throws CommitIntegrityException
299	{
300	EObject eContainer = object.eContainer();
301	if (eContainer == null)
302	{
303	// It's a top-level object
304	CDOResource resource = object.cdoDirectResource();
305	checkIncluded(resource.cdoID(), "resource of " + msgFrag, object);
306	}
307	else
308	{
309	CDOObject container = CDOUtil.getCDOObject(eContainer);
310	checkIncluded(container.cdoID(), "container of " + msgFrag, object);
311	}
312	}
313
314	private void checkCurrentBidiRefTargetsIncluded(CDOObject referencer, String msgFrag) throws CommitIntegrityException
315	{
316	for (EReference eRef : referencer.eClass().getEAllReferences())
317	{
318	if (eRef.getEOpposite() != null)
319	{
320	if (eRef.isMany())
321	{
322	EList<?> list = (EList<?>)referencer.eGet(eRef);
323	for (Object element : list)
324	{
325	checkBidiRefTargetIncluded(element, referencer, msgFrag);
326	}
327	}
328	else
329	{
330	Object refTarget = referencer.eGet(eRef);
331	if (refTarget != null)
332	{
333	checkBidiRefTargetIncluded(refTarget, referencer, msgFrag);
334	}
335	}
336	}
337	}
338	}
339
340	private void checkFormerBidiRefTargetsIncluded(CDOObject referencer, String msgFrag) throws CommitIntegrityException
341	{
342	// The referencer argument should really be a detached object, and so we know
343	// that we can find the pre-detach revision in tx.getFormerRevisions(). However,
344	// the object may have already been dirty prior to detachment, so we check the
345	// clean revisions first.
346	//
347	InternalCDORevision cleanRev = transaction.getCleanRevisions().get(referencer);
348	CheckUtil.checkState(cleanRev, "cleanRev");
349
350	for (EReference eRef : referencer.eClass().getEAllReferences())
351	{
352	if (eRef.getEOpposite() != null)
353	{
354	Object value = cleanRev.get(eRef, EStore.NO_INDEX);
355	if (value != null)
356	{
357	if (eRef.isMany())
358	{
359	EList<?> list = (EList<?>)value;
360	for (Object element : list)
361	{
362	checkBidiRefTargetIncluded(element, referencer, msgFrag);
363	}
364	}
365	else
366	{
367	checkBidiRefTargetIncluded(value, referencer, msgFrag);
368	}
369	}
370	}
371	}
372	}
373
374	private void checkBidiRefTargetIncluded(Object refTarget, CDOObject referencer, String msgFrag)
375	throws CommitIntegrityException
376	{
377	CheckUtil.checkArg(refTarget, "refTarget");
378	CDOID refTargetID = null;
379	if (refTarget instanceof EObject)
380	{
381	refTargetID = CDOUtil.getCDOObject((EObject)refTarget).cdoID();
382	}
383	else if (refTarget instanceof CDOID)
384	{
385	refTargetID = (CDOID)refTarget;
386	}
387	checkIncluded(refTargetID, "reference target of " + msgFrag, referencer);
388	}
389
390	private void checkFormerContainerIncluded(CDOObject detachedObject) throws CommitIntegrityException
391	{
392	InternalCDORevision rev = transaction.getCleanRevisions().get(detachedObject);
393	CheckUtil.checkNull(rev, "Could not obtain clean revision for detached object " + detachedObject);
394	CDOID id = getContainerOrResourceID(rev);
395	checkIncluded(id, "former container (or resource) of detached", detachedObject);
396	}
397
398	/**
399	* Designates an exception style for a {@link CommitIntegrityCheck}
400	*
401	* @author Caspar De Groot
402	*/
403	public enum Style
404	{
405	/**
406	* Throw an exception as soon as this {@link CommitIntegrityCheck} encounters the first problem
407	*/
408	EXCEPTION_FAST,
409
410	/**
411	* Throw an exception when this {@link CommitIntegrityCheck} finishes performing all possible checks, in case any
412	* problems were found
413	*/
414	EXCEPTION,
415
416	/**
417	* Do not throw an exception. Caller must invoke {@link CommitIntegrityCheck#getMissingObjects()} to find out if the
418	* check discovered any problems.
419	*/
420	NO_EXCEPTION
421	}
422	}

Lines 34-39 Link Here

(-)src/org/eclipse/emf/internal/cdo/transaction/CDOXATransactionImpl.java (+11 lines)
34	import org.eclipse.emf.common.notify.Adapter;	34	import org.eclipse.emf.common.notify.Adapter;
35	import org.eclipse.emf.common.notify.Notification;	35	import org.eclipse.emf.common.notify.Notification;
36	import org.eclipse.emf.common.notify.Notifier;	36	import org.eclipse.emf.common.notify.Notifier;
		37	import org.eclipse.emf.ecore.EObject;
37	import org.eclipse.emf.spi.cdo.CDOSessionProtocol;	38	import org.eclipse.emf.spi.cdo.CDOSessionProtocol;
38	import org.eclipse.emf.spi.cdo.CDOSessionProtocol.CommitTransactionResult;	39	import org.eclipse.emf.spi.cdo.CDOSessionProtocol.CommitTransactionResult;
39	import org.eclipse.emf.spi.cdo.CDOTransactionStrategy;	40	import org.eclipse.emf.spi.cdo.CDOTransactionStrategy;
Lines 435-440 Link Here
435	}	436	}
436	}	437	}
437		438
		439	public void setCommittables(Set<EObject> committables)
		440	{
		441	throw new UnsupportedOperationException();
		442	}
		443
		444	public Set<EObject> getCommittables()
		445	{
		446	throw new UnsupportedOperationException();
		447	}
		448
438	/**	449	/**
439	* @author Simon McDuff	450	* @author Simon McDuff
440	*/	451	*/